/// <summary>This ctor upscales a BasePacket. Internally parses OpCode.</summary>
public RawEQPacket(BasePacket packet, bool hasCrc)
{
_rawOpCode = (ushort)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(packet.RawPacketData, 0));
if (_rawOpCode < 0x00ff)
_OpCode = (ProtocolOpCode)_rawOpCode;
_clientIPE = packet.ClientIPE;
if (hasCrc)
{
_data = new byte[packet.RawPacketData.Length - 2];
Buffer.BlockCopy(packet.RawPacketData, 0, _data, 0, packet.RawPacketData.Length - 2);
}
else
{
_data = new byte[packet.RawPacketData.Length];
Buffer.BlockCopy(packet.RawPacketData, 0, _data, 0, packet.RawPacketData.Length);
}
}
// Do any basic processing common to all packets
private void PreProcessRecvPacket(BasePacket packet)
{
Client client;
_clientListLock.EnterReadLock();
_clients.TryGetValue(packet.ClientIPE.ToString(), out client);
_clientListLock.ExitReadLock();
ProtocolOpCode opCode = (ProtocolOpCode)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(packet.RawPacketData, 0));
if (client != null)
{
// Found an existing client
if (client.ConnectionState == ConnectionState.Closed)
return; // ignore packets for closed connections
}
else
{
if (opCode != ProtocolOpCode.SessionRequest)
return; // no client and not a session request - so ignore it
else
client = new Client(packet.ClientIPE);
}
// CRC
bool hasCrc = false;
if (opCode != ProtocolOpCode.SessionRequest && opCode != ProtocolOpCode.SessionResponse && opCode != ProtocolOpCode.OutOfSession)
{
hasCrc = true;
ushort sentCRC = (ushort)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(packet.RawPacketData, packet.RawPacketData.Length - 2));
if (sentCRC != (ushort)CRC.ComputeChecksum(packet.RawPacketData, packet.RawPacketData.Length - 2, client.Key))
{
_log.Error("Packet failed checksum. Client key: " + client.Key);
return;
}
PreProcessInPacket(ref packet); // Let the app level server get a crack at the packet
}
ProcessRecvPacket(new RawEQPacket(packet, hasCrc), client);
}
private void EnqueueRecvPacket(BasePacket packet)
{
lock (((ICollection)_recvQueue).SyncRoot)
_recvQueue.Enqueue(packet);
_readerWaitHandle.Set(); // Signal reader proc
}
/// <summary>Implemented by derived class to perform any necessary packet decompression and/or decryption.</summary>
internal virtual void PreProcessInPacket(ref BasePacket packet)
{
}
internal override void PacketReceived(BasePacket packet)
{
// fast method of enqueueing so we don't drop any packets by doing a lot of work in this method
ThreadPool.QueueUserWorkItem(new WaitCallback(EnqueueRecvPacket), packet);
}
internal void AsyncBeginSend(BasePacket packet)
{
_rwLock.EnterReadLock();
if (!_shutdownFlag)
{
try
{
Interlocked.Increment(ref _rwOpCount);
//_log.DebugFormat("Bytes Sent Dump: {0}", BitConverter.ToString(packet.RawPacketData));
_client.BeginSend(packet.RawPacketData, packet.RawPacketData.Length, packet.ClientIPE, new AsyncCallback(AsyncEndSend), null);
}
catch (SocketException se)
{
_log.Error("Error sending data to client.", se);
Interlocked.Decrement(ref _rwOpCount); // operation is void - decrement pending op count
}
}
_rwLock.ExitReadLock();
}
internal abstract void PacketReceived(BasePacket packet);
internal override void PreProcessInPacket(ref BasePacket packet)
{
// decompress the packet
byte[] unCompBuffer = new byte[COMPRESSION_BUFFER_SIZE];
int unCompLen = EQRawApplicationPacket.Inflate(packet.RawPacketData, ref unCompBuffer);
Array.Resize<byte>(ref unCompBuffer, unCompLen);
packet = new BasePacket(packet.ClientIPE, unCompBuffer);
//_log.Debug(string.Format("inflated packet data: {0}.", BitConverter.ToString(unCompBuffer)));
}
public void SendSequencedPacket(BasePacket appPacket, ProtocolOpCode opCode)
{
// Wrap in a raw packet and throw on sequenced queue
ushort nextOutSeq_no = (ushort)IPAddress.HostToNetworkOrder((short)_nextOutSeq);
RawEQPacket packet = new RawEQPacket(opCode, nextOutSeq_no, appPacket.RawPacketData, appPacket.ClientIPE);
_nextOutSeq++;
lock (((ICollection)_seqQueue).SyncRoot)
_seqQueue.Enqueue(packet);
}
