void HandleInboundPacket(NetInboundPacket packet)
{
if (IsPingPacket(packet.Type))
{
HandlePingPacket(packet);
}
else if (packet.Type == NetPacketType.AckResponse)
{
// Handle ack
ushort ackid = packet.ReadUInt16();
if (NetLogger.LogAcks)
{
NetLogger.LogVerbose("[ACK] Received {0} from {1}", ackid, packet.Sender);
}
packet.Sender.HandleAck(ackid);
}
else if (packet.Type == NetPacketType.Custom)
{
receivedPackets.Enqueue(packet);
}
else if (packet.Type == NetPacketType.Disconnected)
{
string reason = packet.ReadString();
bool lostConnection = packet.ReadBool();
packet.Sender.Disconnect(reason, lostConnection);
}
else if (IsRemotePacket(packet.Type))
{
HandleRemotePacket(packet);
}
else
{
NetLogger.LogWarning("Invalid packet sent from {0}. Type: {1}", packet.Sender, packet.Type);
}
}
void ReplyAck(NetInboundPacket packet, IPEndPoint sender)
{
// Create the ack packet
NetOutboundPacket ack = new NetOutboundPacket(NetDeliveryMethod.Unreliable, 3);
ack.Type = NetPacketType.AckResponse;
ack.Write(packet.Id); // Write the id
if (NetLogger.LogAcks)
{
NetLogger.LogVerbose("[ACK] Replying {0} to {1}", packet.Id, packet.Sender);
}
// And send
packet.Sender.SendPacket(ack);
}
NetOutboundPacket[] SplitPacketIntoPartials(NetOutboundPacket packet)
{
packet.position = 0;
// Calculate the number of packets to split it into,
// and each of their sizes
int numPackets = (int)Math.Ceiling((double)(packet.Length) / (MTU - 12));
int newPacketSize = MTU - 12;
int packetChunkIndex = 0;
ushort id = nextPartialId++;
NetOutboundPacket[] partialPackets = new NetOutboundPacket[numPackets];
for (byte i = 0; i < numPackets; i++)
{
int packetSize = Math.Min(newPacketSize, packet.Length - packetChunkIndex);
// Create the new partial
NetOutboundPacket partial = packet.Clone(true);
partial.isPartial = true;
partial.Encrypt = false;
partial.Compression = NetPacketCompression.None;
partial.Clear(6 + packetSize);
// Write the partial header
partial.Write(id);
partial.Write(i);
partial.Write((byte)numPackets);
partial.Write((ushort)packetSize);
// Write the data allocated to this partial
partial.WriteBytes(packet.ReadBytes(packetChunkIndex, packetSize));
// Add it to the list of partials
partialPackets[i] = partial;
packetChunkIndex += packetSize;
}
if (NetLogger.LogPartials)
{
NetLogger.LogVerbose("[Partial] Split Packet into {0} parts; Size: {1}b, Original Size: {2}b",
numPackets, newPacketSize, packet.Length);
}
return(partialPackets);
}
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);
}
void AddPacketToChunkQueue(NetOutboundPacket packet)
{
// If it is reliable we need to mark it as a new send
TryMarkReliablePacket(packet);
// Log send
if (NetLogger.LogPacketSends && CanLogSend(packet.Type) && !IsPingPacket(packet.Type))
{
NetLogger.LogVerbose("[Outbound:{0}] {1}", EndPoint, packet.ToInternalString());
}
// Send packet or add it to queue
if (packet.SendImmediately)
{
// Just send it if needed
SendPacketToSocket(packet); // Send
}
else
{
// Try to add the packet to the chunked queue
if (!packetChunkQueue.Add(packet))
{
NetLogger.LogError(
"Failed to add packet to the chunk queue. Id: {0}, Type: {1}, DeliveryMethod: {2}, Duplicate Id Added: {3}",
packet.Id, packet.Type, packet.DeliveryMethod, packetChunkQueue.Contains(packet));
}
else
{
// Increment the chunks current size
currentChunkSize += packet.Length;
// If the chunk is too big, send it before any other chunks are added
if (currentChunkSize >= maxChunkSize)
{
SendChunk();
}
}
}
}
void AddRecentPing(int ping)
{
// Add the new ping
recentPings[avgPingI++] = ping;
// If we've reached the end of one ping collection
if (avgPingI == recentPings.Length)
{
// Average the pings we collected
AverageRecentPings();
avgPingI = 0;
// If we are calculating the base ping as well, set it
if (baseAvgPing == -1)
{
if (NetLogger.LogFlowControl)
{
NetLogger.LogVerbose("[FlowControl] Base Ping for {0} set to {1}", EndPoint, lastAvgPing);
}
baseAvgPing = lastAvgPing;
}
else if (NetTime.Now - sendRateSwitchCooldown >= 0)
{
// If the ping increased too much, drop the send rate
if (lastAvgPing - baseAvgPing > 80)
{
sendRateDropped = true;
if (!config.DontApplyPingControl)
{
if (!NetLogger.IgnoreSendRateChanges)
{
NetLogger.LogWarning("[FlowControl] Dropped send rate for {0}", EndPoint);
}
chunkSendDelay = droppedSendRate[0];
PacketSendRate = droppedSendRate[1];
}
sendRateSwitchCooldown = NetTime.Now + sendRateSwitchCooldownDelay;
}
// If the ping returned to normal, try increasing the send rate
else if (sendRateDropped && lastAvgPing - baseAvgPing < 80)
{
sendRateDropped = false;
if (!config.DontApplyPingControl)
{
if (!NetLogger.IgnoreSendRateChanges)
{
NetLogger.Log("[FlowControl] Send rate set to normal for {0}", EndPoint);
}
chunkSendDelay = normalSendRate[0];
PacketSendRate = normalSendRate[1];
}
sendRateSwitchCooldown = NetTime.Now + sendRateSwitchCooldownDelay;
}
// If the average ping dropped, see if we can lower the base ping
else if (!sendRateDropped && lastAvgPing - baseAvgPing < -20)
{
if (NetLogger.LogFlowControl)
{
NetLogger.LogVerbose("[FlowControl] Attempting to increase base ping for {0}...", EndPoint);
}
RecalculateBasePing();
}
}
}
}
void MTUHeartbeat(int now)
{
if (mtu_status == MTUStatus.Unset)
{
// Prep next MTU test
mtu_status = MTUStatus.Setting;
nextMTUTest = now + MTU_UnsetTry_Delay + 1.5f + Stats.Ping;
if (NetLogger.LogFlowControl)
{
NetLogger.LogVerbose("[FlowControl] Expanding MTU for {0}...", EndPoint);
}
}
else if (now >= nextMTUTest)
{
if (mtu_status == MTUStatus.Setting)
{
// Try and send an MTU packet
if (lastMTUTest < NetMessenger.MAX_UDP_PACKET_SIZE && TrySendMTU(lastMTUTest))
{
// If it succeeds then continue
lastMTUTest = (int)(lastMTUTest * MTU_TryInc);
now += MTU_UnsetTry_Delay;
}
else
{
// If it fails, set the MTU and stop trying to expand it
if (lastMTUTest > NetMessenger.MAX_UDP_PACKET_SIZE)
{
lastMTUTest = NetMessenger.MAX_UDP_PACKET_SIZE;
}
// Use 75% of the MTU as the max chunk size, and cap it at 5000 bytes.
maxChunkSize = (int)Math.Min(MaxUDP_MTU, lastMTUTest * 0.75f);
MTU = maxChunkSize;
Stats.MTU = MTU;
MTUEventNeedsCall = true;
if (NetLogger.LogFlowControl)
{
NetLogger.LogVerbose("[FlowControl] MTU for {0} set to {1}", EndPoint, MTU);
}
mtu_status = MTUStatus.Set;
now += MTU_SetTry_Delay;
}
}
// No need.
/*else if (status == MTUStatus.Set)
* {
* int tryExpandAmount = Math.Min((int)(lastMTUTest * MTU_TryInc), MaxUDP_MTU);
*
* if (TrySendMTU(tryExpandAmount))
* {
* lastMTUTest = (int)(lastMTUTest * MTU_TryInc);
* now += MTU_UnsetTry_Delay;
* MTU_Status = MTUStatus.Setting;
* NetLogger.LogVerbose("Expanding MTU further for {0}...", EndPoint);
* }
* else
* now += MTU_SetTry_Delay;
* }*/
}
}
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");
}
}
