public void HandleMultiData(SOEClient sender, SOEMessage message)
{
// Setup a reader and skip the OpCode
SOEReader reader = new SOEReader(message);
int offset = 2;
// Get the data length
int dataLength = message.GetLength();
// Get the packets
while (offset < dataLength)
{
// Message size
int MessageSize = reader.ReadByte();
byte extendedMessageAmount = 0;
// If the first byte is 0xFF then:
// Read how many bytes to add, and then add that many
if (MessageSize == 0xFF)
{
// How many bytes are there?
extendedMessageAmount = reader.ReadByte();
// Add that many bytes
for (int i = 0; i < extendedMessageAmount; i++)
{
MessageSize += reader.ReadByte();
}
extendedMessageAmount++;
}
// Read the Message data from the size
byte[] data = reader.ReadBytes(MessageSize);
// Handle the Message
sender.ReceiveMessage(data);
// Move along
offset += MessageSize + extendedMessageAmount + 1;
}
}
private byte[] DecryptPacket(SOEClient sender, byte[] packet)
{
// Compressable?
if (!sender.IsEncrypted())
{
return packet;
}
// Setup our streams
SOEReader reader = new SOEReader(packet);
SOEWriter newPacket = new SOEWriter(reader.ReadUInt16());
// Skip the compression flag
reader.ReadByte();
// Get our data
int blockCount = (packet.Length - 3) / 4;
int byteCount = (packet.Length - 3) % 4;
uint key = sender.GetCRCSeed();
// Decrypt the blocks of 4 bytes
for (int i = 0; i < blockCount; i++)
{
uint temp = reader.ReadUInt32();
uint value = temp ^ key;
key = temp;
newPacket.AddUInt32(value);
}
// Decrypt the rest of the singular bytes
byte newKey = (byte)((key >> 24) & 0xFF);
for (int i = 0; i < byteCount; i++)
{
byte value = (byte)(reader.ReadByte() ^ newKey);
newPacket.AddByte(value);
}
// Return the decrypted packet
return newPacket.GetRaw();
}
private void ReceiveFragment(SOEPacket packet)
{
// Setup a reader
SOEReader reader = new SOEReader(packet);
reader.ReadUInt16();
// Have we already started a fragmented packet?
if (StartedFragmentedPacket)
{
// One less fragment till we need to acknowledge!
FragmentsTillAck--;
// Get our sequence number
uint previousFragmentSequenceNumber = FragmentSequenceNumber;
FragmentSequenceNumber = reader.ReadUInt16();
// Did we get a correct sequence number?
if (FragmentSequenceNumber != previousFragmentSequenceNumber + 1)
{
// Out of order!
ReceivedSequenceOutOfOrder(FragmentSequenceNumber);
return;
}
// Append the rest of the packet to the fragmented data
for (int i = 4; i < FragmentedData.Length; i++)
{
FragmentedData[ReceivedFragmentsSize] = reader.ReadByte();
ReceivedFragmentsSize++;
}
}
else
{
// We're expecting the starting packet
FragmentSequenceNumber = reader.ReadUInt16();
uint totalSize = reader.ReadUInt32();
// Is this a valid sequence number?
if ((FragmentSequenceNumber != LastReceivedSequenceNumber + 1) && (FragmentSequenceNumber != 0))
{
// Out of order!
ReceivedSequenceOutOfOrder(FragmentSequenceNumber);
return;
}
// Get the total size
FragmentedData = new byte[totalSize];
// How many fragments till we need to acknowledge
FragmentsTillAck = 4;
// Append the rest of the packet to the fragmented data
for (int i = 8; i < FragmentedData.Length; i++)
{
FragmentedData[ReceivedFragmentsSize] = reader.ReadByte();
ReceivedFragmentsSize++;
}
// Started a fragmented packet
StartedFragmentedPacket = true;
}
// Are we finished with the fragmented data?
if (ReceivedFragmentsSize >= FragmentedData.Length)
{
// Finish fragmented packet
StartedFragmentedPacket = false;
FragmentsTillAck = 0;
// Handle the fragmented packet as a RELIABLE_DATA packet
SOEWriter writer = new SOEWriter((ushort)SOEOPCodes.RELIABLE_DATA);
writer.AddBytes(FragmentedData);
SOEPacket wholePacket = writer.GetFinalSOEPacket(Client, false, false);
// Receive this packet!
Receive(wholePacket);
return;
}
// Do we need to acknowledge?
if (FragmentsTillAck == 0)
{
Acknowledge(FragmentSequenceNumber);
FragmentsTillAck = 5;
}
}
public byte[] Encrypt(SOEClient client, byte[] data)
{
SOEReader reader = new SOEReader(data);
SOEWriter newPacket = new SOEWriter();
int blockCount = data.Length / 4;
int byteCount = data.Length % 4;
uint key = client.GetCRCSeed();
// Encrypt the blocks of 4 bytes
for (int i = 0; i < blockCount; i++)
{
uint value = key = reader.ReadUInt32() ^ key;
newPacket.AddUInt32(value);
}
// Encrypt the rest of the singular bytes
byte newKey = (byte)((key >> 24) & 0xFF);
for (int i = 0; i < byteCount; i++)
{
byte value = (byte)(reader.ReadByte() ^ newKey);
newPacket.AddByte(value);
}
// Return the encrypted packet
return newPacket.GetRaw();
}