public async Task <bool> ReadData()
{
if (isReading)
{
return(true);
}
isReading = true;
try {
while (tcpClient != null)
{
try {
var stream = tcpClient.GetStream();
var bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
break;
}
streamData += Encoding.UTF8.GetString(buffer, 0, bytesRead);
} catch (SocketException ex) {
Console.WriteLine(ex.Message);
return(false);
} catch (IOException ex) {
Console.WriteLine(ex.Message);
return(false);
} catch (ObjectDisposedException ex) {
Console.WriteLine(ex.Message);
return(false);
}
while (true)
{
var packet = ParsePacket();
if (packet == null)
{
break;
}
PacketReceived.Raise(this, packet);
var id = packet.Id;
if (PopDelta(id))
{
PushPacket(packet);
}
}
}
} finally {
isReading = false;
if (readingTaskSignal != null)
{
readingTaskSignal.SetResult();
}
}
return(true);
}
public void Update()
{
lock (_sync)
{
Queue <Packet> temp = _workingQueue;
_workingQueue = _queue;
_queue = temp;
}
while (_queue.Count > 0)
{
PacketReceived.Raise(_queue.Dequeue());
}
Flush();
}
public void Update()
{
//if (!IsConnected)
// return;
lock (_sync)
{
Queue <Packet> temp = _workingQueue;
_workingQueue = _queue;
_queue = temp;
}
while (_queue.Count > 0)
{
PacketReceived.Raise(_queue.Dequeue());
}
Flush();
}
public void Update()
{
lock (_sync)
{
Queue <Packet> temp = _workingQueue;
_workingQueue = _queue;
_queue = temp;
}
while (_queue.Count > 0)
{
Packet p = _queue.Dequeue();
if (Plugin.ProcessRecvPacket(p.ToArray(), p.Length))
{
PacketReceived.Raise(p);
}
}
Flush();
}
private void OnPacketReceived(object sender, Packet packet)
{
PacketReceived.Raise(this, packet);
}
protected unsafe override void ProcessReceivedMessage(
IPHeader ipHeader, TCPHeader tcpHeader, byte *data, int dataOffset, int dataLength)
{
// OK, get the packet direction.
var direction = GetDirection(ipHeader, tcpHeader);
// OK, get the right address according to the direction.
var address = GetAddress(direction, ipHeader);
// Start the fight!
if (dataLength <= 0)
{
return;
}
else if (dataLength == 4) // Hand-shake packet.
{
var helloPacket = *(uint *)&data[dataOffset];
if (helloPacket == 0x1F11F311)
{
return;
}
}
else if (dataLength < PacketHeaderSize) // Not a valid 12-byte header.
{
return;
}
else // Data >= sizeof(PacketHeader)
{
if (m_isFragmenting) // Is a fragment
{
// If the received length is less than the first fragment length
// and the total fragments can carry at least 1 full header specified message
if (dataLength < m_firstFragmentSize &&
(m_totalFragmentsSize + dataLength) >= m_fragmentHeaderSize)
{ // Add the last fragment to the list
AddFragment(address, ipHeader.Id, dataOffset, dataLength);
// Consolidate the message into a single buffer.
var msgBuffer = ConsolidateFragments(address);
if (msgBuffer == null)
{
return;
}
var remaining = msgBuffer.Length;
var currentOffset = 0;
fixed(byte *pMsgBuffer = msgBuffer)
{ // We need a do-while loop, because we may get two messages
// glued together by tcp-fragmentation.
do
{
var pSize = *(ushort *)&pMsgBuffer[currentOffset];
W2PacketSecurity.Decrypt(pMsgBuffer, pSize, currentOffset);
var pHeader = PacketHeader.Parse(&pMsgBuffer[currentOffset]);
remaining -= pSize;
// Creates a new buffer, with only the current packet.
// This ensures that we will not use the same underlyng buffer
// because this buffer will be stored by the forms...
byte[] packetBuffer = new byte[pSize];
W2MarshalHelper.BufferCopy(msgBuffer, currentOffset, packetBuffer, 0, pSize);
PacketReceived.Raise(this, new W2PacketEventArgs(pHeader, direction, ipHeader,
tcpHeader, packetBuffer));
currentOffset += pSize;
} while (remaining >= PacketHeaderSize);
}
m_isFragmenting = false;
m_fragmentHeaderSize = 0;
m_totalFragmentsSize = 0;
m_fragmentedBuffers[address].Clear();
return;
}
else
{
AddFragment(address, ipHeader.Id, dataOffset, dataLength);
return;
}
}
if (dataLength == 120)
{
var helloPacket = *(uint *)&data[dataOffset];
if (helloPacket == 0x1F11F311)
{
dataOffset += 4;
}
}
// Gets the first ushort, which is supposed to carry the size of the packet.
var headerSize = *(ushort *)&data[dataOffset];
// Not a valid packet size.
if (headerSize < PacketHeaderSize || headerSize > MaxPacketSize)
{
return;
}
if (headerSize > dataLength) // The packet will be fragmented.
{
AddFragment(address, ipHeader.Id, dataOffset, dataLength);
m_isFragmenting = true;
m_firstFragmentSize = dataLength;
m_fragmentHeaderSize = headerSize;
return;
}
else // No Fragmentation...
{
var remaining = dataLength;
var currentOffset = dataOffset;
do
{
var pSize = *(ushort *)&data[currentOffset];
W2PacketSecurity.Decrypt(data, pSize, currentOffset);
var pHeader = PacketHeader.Parse(&data[currentOffset]);
remaining -= pSize;
// Creates a temp. buffer for the handler.
byte[] packetBuffer = new byte[pSize];
W2MarshalHelper.BufferCopy(m_buffer, currentOffset, packetBuffer, 0, pSize);
PacketReceived.Raise(this, new W2PacketEventArgs(pHeader, direction, ipHeader, tcpHeader,
packetBuffer));
currentOffset += pSize;
} while (remaining >= PacketHeaderSize);
}
}
}
