public void SmallDataCompressionTestLevel1()
{
byte[] smallData = new byte[100];
new Random().NextBytes(smallData);
byte[] smallDataCompressed = SafeQuickLZ.Compress(smallData, 1);
Assert.AreNotEqual(smallData, smallDataCompressed, "Original data is equal to the compressed data!");
byte[] smallDataDecompressed = SafeQuickLZ.Decompress(smallDataCompressed);
Assert.AreNotEqual(smallDataCompressed, smallDataDecompressed, "Compressed data is equal to the decompressed data!");
CollectionAssert.AreEqual(smallData, smallDataDecompressed, "Original data does not match the decompressed data!");
}
public void BigDataCompressionTestLevel3()
{
var bigData = new byte[100000];
new Random().NextBytes(bigData);
var bigDataCompressed = SafeQuickLZ.Compress(bigData, 3);
Assert.AreNotEqual(bigData, bigDataCompressed, "Original data is equal to the compressed data!");
var bigDataDecompressed = SafeQuickLZ.Decompress(bigDataCompressed);
Assert.AreNotEqual(bigDataCompressed, bigDataDecompressed,
"Compressed data is equal to the decompressed data!");
CollectionAssert.AreEqual(bigData, bigDataDecompressed,
"Original data does not match the decompressed data!");
}
public void BigDataCompressionTestLevel3()
{
byte[] bigData = new byte[100000];
// Fill the big data array with random data.
new Random().NextBytes(bigData);
// Store the compressed data.
byte[] bigDataCompressed = SafeQuickLZ.Compress(bigData, 3);
// The original should not equal the compressed data.
Assert.AreNotEqual(bigData, bigDataCompressed, "Original data is equal to the compressed data!");
// Store the decompressed data.
byte[] bigDataDecompressed = SafeQuickLZ.Decompress(bigDataCompressed);
// The compressed data should not equal the decompressed data.
Assert.AreNotEqual(bigDataCompressed, bigDataDecompressed, "Compressed data is equal to the decompressed data!");
// The original data must equal the decompressed data; must be able to make a round-trip.
CollectionAssert.AreEqual(bigData, bigDataDecompressed, "Original data does not match the decompressed data!");
}
public void SmallDataCompressionTestLevel3()
{
byte[] smallData = new byte[100];
// Fill the small data array with random data.
new Random().NextBytes(smallData);
// Store the compressed data.
byte[] smallDataCompressed = SafeQuickLZ.Compress(smallData, 3);
// The original should not equal the compressed data.
Assert.AreNotEqual(smallData, smallDataCompressed);
// Store the decompressed data.
byte[] smallDataDecompressed = SafeQuickLZ.Decompress(smallDataCompressed);
// The compressed data should not equal the decompressed data.
Assert.AreNotEqual(smallDataCompressed, smallDataDecompressed);
// The original data must equal the decompressed data; must be able to make a round-trip.
CollectionAssert.AreEqual(smallData, smallDataDecompressed);
}
public void SmallDataCompressionTestLevel3()
{
SafeQuickLZ safeQuickLZtest = new SafeQuickLZ();
byte[] smallData = new byte[100];
// Fill the small data array with random data.
new Random().NextBytes(smallData);
// Store the compressed data.
byte[] smallDataCompressed = safeQuickLZtest.Compress(smallData, 0, smallData.Length, 3);
// The original should not equal the compressed data.
Assert.AreNotEqual(smallData, smallDataCompressed, "Original data is equal to the compressed data!");
// Store the decompressed data.
byte[] smallDataDecompressed = safeQuickLZtest.Decompress(smallDataCompressed, 0, smallDataCompressed.Length);
// The compressed data should not equal the decompressed data.
Assert.AreNotEqual(smallDataCompressed, smallDataDecompressed, "Compressed data is equal to the decompressed data!");
// The original data must equal the decompressed data; must be able to make a round-trip.
CollectionAssert.AreEqual(smallData, smallDataDecompressed, "Original data does not match the decompressed data!");
}
private void AsyncReceive(object state)
{
while (true)
{
byte[] readBuffer;
lock (_readBuffers)
{
if (_readBuffers.Count == 0)
{
lock (_readingPacketsLock)
{
_readingPackets = false;
}
return;
}
readBuffer = _readBuffers.Dequeue();
}
_readableDataLen += readBuffer.Length;
bool process = true;
while (process)
{
switch (_receiveState)
{
case ReceiveType.Header:
{
if (_readableDataLen >= _parentServer.HEADER_SIZE)
{ // we can read the header
int headerLength = (_appendHeader)
? _parentServer.HEADER_SIZE - _tempHeaderOffset
: _parentServer.HEADER_SIZE;
try
{
if (_appendHeader)
{
try
{
Array.Copy(readBuffer, _readOffset, _tempHeader, _tempHeaderOffset,
headerLength);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_payloadLen = BitConverter.ToInt32(_tempHeader, 0);
_tempHeaderOffset = 0;
_appendHeader = false;
}
else
{
_payloadLen = BitConverter.ToInt32(readBuffer, _readOffset);
}
if (_payloadLen <= 0 || _payloadLen > _parentServer.MAX_PACKET_SIZE)
{
throw new Exception("invalid header");
}
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_readableDataLen -= headerLength;
_readOffset += headerLength;
_receiveState = ReceiveType.Payload;
}
else // _parentServer.HEADER_SIZE < _readableDataLen
{
try
{
Array.Copy(readBuffer, _readOffset, _tempHeader, _tempHeaderOffset, _readableDataLen);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_tempHeaderOffset += _readableDataLen;
_appendHeader = true;
process = false;
}
break;
}
case ReceiveType.Payload:
{
if (_payloadBuffer == null || _payloadBuffer.Length != _payloadLen)
{
_payloadBuffer = new byte[_payloadLen];
}
int length = (_writeOffset + _readableDataLen >= _payloadLen)
? _payloadLen - _writeOffset
: _readableDataLen;
try
{
Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, length);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_writeOffset += length;
_readOffset += length;
_readableDataLen -= length;
if (_writeOffset == _payloadLen)
{
if (encryptionEnabled)
{
_payloadBuffer = AES.Decrypt(_payloadBuffer);
}
bool isError = _payloadBuffer.Length == 0; // check if payload decryption failed
if (_payloadBuffer.Length > 0)
{
if (compressionEnabled)
{
_payloadBuffer = SafeQuickLZ.Decompress(_payloadBuffer);
}
isError = _payloadBuffer.Length == 0; // check if payload decompression failed
}
if (isError)
{
process = false;
Disconnect();
break;
}
using (MemoryStream deserialized = new MemoryStream(_payloadBuffer))
{
IPacket packet = (IPacket)_serializer.Deserialize(deserialized);
OnClientRead(packet);
}
_receiveState = ReceiveType.Header;
_payloadBuffer = null;
_payloadLen = 0;
_writeOffset = 0;
}
if (_readableDataLen == 0)
{
process = false;
}
break;
}
}
}
if (_receiveState == ReceiveType.Header)
{
_writeOffset = 0; // prepare for next packet
}
_readOffset = 0;
_readableDataLen = 0;
}
}
// Token: 0x06000144 RID: 324 RVA: 0x000087A0 File Offset: 0x000069A0
private void AsyncReceive(object state)
{
for (;;)
{
byte[] array;
lock (this._readBuffers)
{
if (this._readBuffers.Count == 0)
{
lock (this._readingPacketsLock)
{
this._readingPackets = false;
}
break;
}
array = this._readBuffers.Dequeue();
}
this._readableDataLen += array.Length;
bool flag3 = true;
while (flag3)
{
switch (this._receiveState)
{
case Client.ReceiveType.Header:
if (this._readableDataLen >= this.HEADER_SIZE)
{
int num = this._appendHeader ? (this.HEADER_SIZE - this._tempHeaderOffset) : this.HEADER_SIZE;
try
{
if (this._appendHeader)
{
try
{
Array.Copy(array, this._readOffset, this._tempHeader, this._tempHeaderOffset, num);
}
catch (Exception ex)
{
flag3 = false;
this.OnClientFail(ex);
break;
}
this._payloadLen = BitConverter.ToInt32(this._tempHeader, 0);
this._tempHeaderOffset = 0;
this._appendHeader = false;
}
else
{
this._payloadLen = BitConverter.ToInt32(array, this._readOffset);
}
if (this._payloadLen <= 0 || this._payloadLen > this.MAX_PACKET_SIZE)
{
throw new Exception("invalid header");
}
}
catch (Exception)
{
flag3 = false;
this.Disconnect();
break;
}
this._readableDataLen -= num;
this._readOffset += num;
this._receiveState = Client.ReceiveType.Payload;
}
else
{
try
{
Array.Copy(array, this._readOffset, this._tempHeader, this._tempHeaderOffset, this._readableDataLen);
}
catch (Exception ex2)
{
flag3 = false;
this.OnClientFail(ex2);
break;
}
this._tempHeaderOffset += this._readableDataLen;
this._appendHeader = true;
flag3 = false;
}
break;
case Client.ReceiveType.Payload:
{
if (this._payloadBuffer == null || this._payloadBuffer.Length != this._payloadLen)
{
this._payloadBuffer = new byte[this._payloadLen];
}
int num2 = (this._writeOffset + this._readableDataLen >= this._payloadLen) ? (this._payloadLen - this._writeOffset) : this._readableDataLen;
try
{
Array.Copy(array, this._readOffset, this._payloadBuffer, this._writeOffset, num2);
}
catch (Exception ex3)
{
flag3 = false;
this.OnClientFail(ex3);
break;
}
this._writeOffset += num2;
this._readOffset += num2;
this._readableDataLen -= num2;
if (this._writeOffset == this._payloadLen)
{
bool flag4;
if (!(flag4 = (this._payloadBuffer.Length == 0)))
{
this._payloadBuffer = GClass18.smethod_6(this._payloadBuffer);
flag4 = (this._payloadBuffer.Length == 0);
}
if (!flag4)
{
try
{
this._payloadBuffer = SafeQuickLZ.Decompress(this._payloadBuffer);
}
catch (Exception)
{
flag3 = false;
this.Disconnect();
break;
}
flag4 = (this._payloadBuffer.Length == 0);
}
if (flag4)
{
flag3 = false;
this.Disconnect();
break;
}
using (MemoryStream memoryStream = new MemoryStream(this._payloadBuffer))
{
try
{
IPacket packet = (IPacket)this._serializer.Deserialize(memoryStream);
this.OnClientRead(packet);
}
catch (Exception ex4)
{
flag3 = false;
this.OnClientFail(ex4);
break;
}
}
this._receiveState = Client.ReceiveType.Header;
this._payloadBuffer = null;
this._payloadLen = 0;
this._writeOffset = 0;
}
if (this._readableDataLen == 0)
{
flag3 = false;
}
break;
}
}
}
if (this._receiveState == Client.ReceiveType.Header)
{
this._writeOffset = 0;
}
this._readOffset = 0;
this._readableDataLen = 0;
}
}
private void AsyncReceive(object state)
{
while (true)
{
byte[] readBuffer;
lock (_readBuffers)
{
if (_readBuffers.Count == 0)
{
lock (_readingmessagesLock)
{
_readingmessages = false;
}
return;
}
readBuffer = _readBuffers.Dequeue();
}
_readableDataLen += readBuffer.Length;
bool process = true;
while (process)
{
switch (_receiveState)
{
case ReceiveType.Header:
{
if (_readableDataLen + _tempHeaderOffset >= _parentServer.HEADER_SIZE)
{ // we can read the header
int headerLength = (_appendHeader)
? _parentServer.HEADER_SIZE - _tempHeaderOffset
: _parentServer.HEADER_SIZE;
try
{
if (_appendHeader)
{
try
{
Array.Copy(readBuffer, _readOffset, _tempHeader, _tempHeaderOffset,
headerLength);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_payloadLen = BitConverter.ToInt32(_tempHeader, 0);
_tempHeaderOffset = 0;
_appendHeader = false;
}
else
{
_payloadLen = BitConverter.ToInt32(readBuffer, _readOffset);
}
if (_payloadLen <= 0 || _payloadLen > _parentServer.MAX_MESSAGE_SIZE)
{
throw new Exception("invalid header");
}
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_readableDataLen -= headerLength;
_readOffset += headerLength;
_receiveState = ReceiveType.Payload;
}
else // _readableDataLen < _parentServer.HEADER_SIZE
{
try
{
Array.Copy(readBuffer, _readOffset, _tempHeader, _tempHeaderOffset, _readableDataLen);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_tempHeaderOffset += _readableDataLen;
_appendHeader = true;
process = false;
}
break;
}
case ReceiveType.Payload:
{
if (_payloadBuffer == null || _payloadBuffer.Length != _payloadLen)
{
_payloadBuffer = new byte[_payloadLen];
}
int length = (_writeOffset + _readableDataLen >= _payloadLen)
? _payloadLen - _writeOffset
: _readableDataLen;
try
{
Array.Copy(readBuffer, _readOffset, _payloadBuffer, _writeOffset, length);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
_writeOffset += length;
_readOffset += length;
_readableDataLen -= length;
if (_writeOffset == _payloadLen)
{
bool isError = _payloadBuffer.Length == 0;
if (!isError)
{
if (encryptionEnabled)
{
_payloadBuffer = AES.Decrypt(_payloadBuffer);
}
isError = _payloadBuffer.Length == 0; // check if payload decryption failed
}
int compressedSize = _payloadBuffer.Length;
if (!isError)
{
if (compressionEnabled)
{
try
{
_payloadBuffer = SafeQuickLZ.Decompress(_payloadBuffer);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
}
isError = _payloadBuffer.Length == 0; // check if payload decompression failed
}
if (isError)
{
process = false;
Disconnect();
break;
}
int uncompressedSize = _payloadBuffer.Length;
double ratio = (double)uncompressedSize / compressedSize - 1;
string save = "nothing";
if (ratio > 0)
{
save = Helper.FileHelper.GetDataSize(uncompressedSize - compressedSize);
}
System.Diagnostics.Debug.WriteLine($"Read ratio: {ratio}, saved {save}");
using (MemoryStream deserialized = new MemoryStream(_payloadBuffer))
{
try
{
IMessage message = Serializer.Deserialize <IMessage>(deserialized);
OnClientRead(message);
}
catch (Exception)
{
process = false;
Disconnect();
break;
}
}
_receiveState = ReceiveType.Header;
_payloadBuffer = null;
_payloadLen = 0;
_writeOffset = 0;
}
if (_readableDataLen == 0)
{
process = false;
}
break;
}
}
}
if (_receiveState == ReceiveType.Header)
{
_writeOffset = 0; // prepare for next message
}
_readOffset = 0;
_readableDataLen = 0;
}
}