void SetupOutboundPacket(NetOutboundPacket packet)
{
// Compress Packet
if (packet.Compression != NetPacketCompression.None && !packet.isCompressed &&
((packet.Compression == NetPacketCompression.Compress && packet.Length > 40) ||
(config.AutoCompressPackets && packet.Length > config.CompressPacketAfter)))
{
NetCompressor.Compress(packet);
}
// Encrypt Packet
if (packet.Encrypt)
{
NetEncryption.EncryptPacket(packet);
}
}
internal void SendInternalPacket(NetOutboundPacket packet, IPEndPoint to)
{
packet.RemovePadding();
packet.SetId(AllocatePacketId());
if (packet.Type == NetPacketType.ConnectionRequest)
{
NetEncryption.EncryptPacket(packet);
}
packet.PrependHeader();
if (NetLogger.LogPacketSends && !IsPingPacket(packet.Type))
{
NetLogger.LogVerbose("[Outbound:{0}] {1}", to, packet.ToInternalString());
}
SendDataToSocket(packet.data, to, false);
}
bool HandlePartial(ref NetInboundPacket packet)
{
// Read the partials header (6 bytes)
ushort partialId = packet.ReadUInt16();
byte index = packet.ReadByte();
byte numPartials = packet.ReadByte();
ushort partialSize = packet.ReadUInt16();
PartialPacket partial;
// See if the partial already exists
if (!packet.Sender.Partials.TryGetValue(partialId, out partial))
{
// Since the partial doesn't exist, create one.
if (!packet.Sender.Partials.TryAdd(partialId,
partial = new PartialPacket(packet.Sender, partialId, numPartials, partialSize)))
{
//NetLogger.LogError("[Partial:{0}:{1}] Failed to add new partial!", packet.Sender.EndPoint, partialId);
//return false;
// TODO: See if theres a better way to handle this partial packet concurrency issue
// If for some reason, two partials are processed simultaneously,
// and it tried adding two packets at once,
// we'll just grab the packet created by the other and move on.
partial = packet.Sender.Partials[partialId];
}
else
{
if (NetLogger.LogPartials)
{
NetLogger.LogVerbose("[Partial:{0}:{1}] Starting new; NumPackets: {2}; PacketSize: {3}b",
packet.Sender, partialId, numPartials, partialSize);
}
}
}
// Add the current partial
if (partial.AddPacket(index, packet.ReadBytes(partialSize)))
{
if (NetLogger.LogPartials)
{
NetLogger.LogVerbose("[Partial:{0}:{1}] Adding index: {2}; PacketsLeft: {3}",
packet.Sender, partialId, index, partial.numPartials - partial.numPartialsReceived);
}
// Check if the partial is complete
if (partial.numPartialsReceived >= partial.numPartials)
{
// Remove the partial from the connections queue
if (packet.Sender.Partials.TryRemove(partial.id, out partial))
{
// Save the old sender
NetConnection sender = packet.Sender;
// Construct the final packet
packet = partial.Construct(packet);
// Reset the packets parameters
packet.ReadOnly = true;
if (NetLogger.LogPartials)
{
NetLogger.LogVerbose("[Partial:{0}:{1}] Constructed final partial; FullSize: {2}b",
sender, partialId, packet.Length);
}
// Process the partial like a physical packet
packet.position = 0;
if (packet.ReadHeader())
{
if (packet.isEncrypted)
{
NetEncryption.DecryptPacket(packet);
}
if (packet.isCompressed)
{
NetCompressor.Decompress(packet);
}
// Update the stats
packet.Sender.PartialPacketReceived(numPartials);
// Tell the caller this partial is ready!
return(true);
}
else
{
// Bad stuff happened
NetLogger.LogWarning("[Partial:{0}:{1}] Constructed partial packet had invalid header!",
sender, partialId);
return(false);
}
}
else
{
NetLogger.LogError("[Partial:{0}:{1}] Failed to remove completed partial!",
packet.Sender, partialId);
}
}
}
// Tell the caller this partial is not complete
return(false);
}
void PacketReceived(byte[] data, IPEndPoint sender, bool parentWasChunk = false)
{
NetInboundPacketBase packet;
NetInboundPacket connectionyPacket = null;
bool connectionless;
NetConnection senderConn;
if (Connections.TryGetValue(sender, out senderConn))
{
connectionless = false;
packet = connectionyPacket = new NetInboundPacket(senderConn, data);
if (!parentWasChunk)
{
senderConn.PhysicalPacketReceived();
}
else
{
senderConn.PacketReceived();
}
}
else
{
connectionless = true;
packet = new NetConnectionlessInboundPacket(sender, data);
}
if (packet.ReadHeader())
{
if (packet.isChunked)
{
byte[][] chunks = packet.GetChunked();
for (int i = 0; i < chunks.Length; i++)
{
PacketReceived(chunks[i], sender, true);
}
}
else
{
if (packet.Type == NetPacketType.MTUTest)
{
return;
}
if (ignoredConnections.Count > 0 && ignoredConnections.ContainsKey(sender))
{
return;
}
bool packetAlreadyReceived = connectionless ? false : !connectionyPacket.Sender.TryHandlePacket(packet.Id);
if (NetLogger.LogPacketReceives && !IsPingPacket(packet.Type) && !packetAlreadyReceived)
{
NetLogger.LogVerbose("[Inbound:{0}] {1}", sender, packet.ToInternalString());
}
if (packet.isReliable && !connectionless)
{
ReplyAck(connectionyPacket, sender);
}
else if (packet.isReliable && connectionless)
{
AddWatchedConnection(sender, "Sent reliable connectionless packet");
}
if (packetAlreadyReceived)
{
if (NetLogger.LogAlreadyHandledPackets)
{
NetLogger.LogWarning("[DUPLICATE PACKET:{0}] Ignoring packet {1}", sender, packet.Id);
}
return;
}
if (packet.isEncrypted)
{
NetEncryption.DecryptPacket(packet);
}
if (packet.isCompressed)
{
NetCompressor.Decompress(packet);
}
if (packet.isPartial)
{
if (connectionyPacket == null)
{
AddWatchedConnection(sender, "Sent connectionless partial packet");
return;
}
if (!HandlePartial(ref connectionyPacket))
{
// Partial is not complete yet, so just return
return;
}
else
{
// Partial is complete, so overrite the current
// packet with the completed packet.
packet = connectionyPacket;
}
}
if (connectionless)
{
HandleConnectionlessInboundPacket((NetConnectionlessInboundPacket)packet);
}
else
{
HandleInboundPacket((NetInboundPacket)packet);
}
}
}
else
{
AddWatchedConnection(sender, "Sent packet with invalid signature");
}
}