unsafe public void Test_SocketObject_SendPacket()
{
MockClient client = new MockClient(42, TestUserIP);
BaseServerPacketMock mockPacket = new MockServer_1B_LoginConfirm(44, 1, 12, 23, 34, 1, 54, 33);
IPackets engine = Server.PacketEngine;
((MockPacketEngine)engine).ClearLast(client);
fixed(byte *p = mockPacket.PacketData)
engine.SocketObject_SendPacket(client.Socket, p, mockPacket.Length);
string result = ((MockPacketEngine)engine).VerifySent(client, mockPacket.PacketData);
Assert.AreEqual(string.Empty, result);
}
private void packetReader(IPackets packet)
{
var type = packet.Type;
if (!authenticated)
{
if (type == TypePackets.GetAuthentication)
{
AuthenticationController.HandleGetAuthentication(this);
}
else if (type == TypePackets.SetAuthenticationSuccess)
{
authenticated = true;
}
return;
}
PacketHandler.packetChecker(this, packet);
}
private void packetReader(IPackets packet)
{
var type = packet.Type;
if (!authenticated)
{
if (type == TypePackets.GetAuthenticationResponse)
{
authenticated = true;
new Packets.ServerPackets.SetAuthenticationSuccess().Execute(this); // finish handshake
AuthenticationController.HandleGetAuthenticationResponse(this, (GetAuthenticationResponse)packet);
DvgUpdater(this, true);
authenticated = true;
}
else
{
disconnect();
}
return;
}
PacketHandler.packetChecker(this, packet);
}
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: // PayloadLength
{
if (_readableDataLen >= HEADER_SIZE)
{
int headerLength = (_appendHeader) ? HEADER_SIZE - _tempHeaderOffset : 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 > MAX_PACKET_SIZE)
{
throw new Exception("invalid header");
}
}
catch (Exception)
{
process = false;
disconnect();
break;
}
_readableDataLen -= headerLength;
_readOffset += headerLength;
_receiveState = ReceiveType.Payload;
}
else // _readableDataLen < 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: //Deserialize 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)
{
process = false;
disconnect();
break;
}
try
{
IPackets packet = ZeroFormatterSerializer.Deserialize <IPackets>(_payloadBuffer);
packetReader(packet);
}
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;
}
_readOffset = 0;
_readableDataLen = 0;
}
}
