private bool ResendPackages(IEnumerable <OutgoingPacket> packetList, ref TimeSpan sleepSpan)
{
TimeSpan maxTimeout = GetTimeout(PacketTimeouts.Length);
foreach (var outgoingPacket in packetList)
{
var nextTest = (outgoingPacket.LastSendTime - Util.Now) + GetTimeout(outgoingPacket.ResendCount);
if (nextTest < TimeSpan.Zero)
{
if (++outgoingPacket.ResendCount > RetryTimeout)
{
#if DEBUG
Console.WriteLine("TIMEOUT: " + DebugUtil.DebugToHex(outgoingPacket.Raw));
#endif
return(true);
}
SendRaw(outgoingPacket);
}
else
{
sleepSpan = Util.Min(sleepSpan, nextTest);
}
}
return(false);
}
private void SendRaw(C2SPacket packet)
{
packet.LastSendTime = Util.Now;
NetworkStats.LogOutPacket(packet);
LoggerRaw.Trace("[O] Raw: {0}", DebugUtil.DebugToHex(packet.Raw));
udpClient.Send(packet.Raw, packet.Raw.Length);
}
private bool ResendPackages(IEnumerable <OutgoingPacket> packetList)
{
var now = Util.Now;
foreach (var outgoingPacket in packetList)
{
// Check if the packet timed out completely
if (outgoingPacket.FirstSendTime < now - PacketTimeout)
{
#if DIAGNOSTICS && DIAG_TIMEOUT
Console.WriteLine("TIMEOUT: " + DebugUtil.DebugToHex(outgoingPacket.Raw));
#endif
return(true);
}
// Check if we should retransmit a packet because it probably got lost
if (outgoingPacket.LastSendTime < now - currentRto)
{
#if DIAGNOSTICS && DIAG_TIMEOUT
Console.WriteLine("RESEND PACKET: " + DebugUtil.DebugToHex(outgoingPacket.Raw));
#endif
currentRto = currentRto + currentRto;
if (currentRto > MaxRetryInterval)
{
currentRto = MaxRetryInterval;
}
SendRaw(outgoingPacket);
}
}
return(false);
}
public override string ToString()
{
return($"Type: {PacketType}\tFlags: [ " +
$"{(FragmentedFlag ? "X" : "_")} {(NewProtocolFlag ? "X" : "_")} " +
$"{(CompressedFlag ? "X" : "_")} {(UnencryptedFlag ? "X" : "_")} ]\t" +
$"Id: {PacketId}\n" +
$" Data: { DebugUtil.DebugToHex(Data) }\n" +
$" ASCI: { Util.Encoder.GetString(Data) }");
}
public S2CPacket FetchPacket()
{
while (true)
{
if (Closed)
{
return(null);
}
if (TryFetchPacket(receiveQueue, out var packet))
{
return(packet);
}
if (TryFetchPacket(receiveQueueLow, out packet))
{
return(packet);
}
var dummy = new IPEndPoint(IPAddress.Any, 0);
byte[] buffer;
try { buffer = udpClient.Receive(ref dummy); }
catch (IOException) { return(null); }
catch (SocketException) { return(null); }
catch (ObjectDisposedException) { return(null); }
if (dummy.Address.Equals(remoteAddress.Address) && dummy.Port != remoteAddress.Port)
{
continue;
}
packet = Ts3Crypt.GetS2CPacket(buffer);
// Invalid packet, ignore
if (packet == null)
{
LoggerRaw.Debug("Dropping invalid packet: {0}", DebugUtil.DebugToHex(buffer));
continue;
}
GenerateGenerationId(packet);
if (!ts3Crypt.Decrypt(packet))
{
continue;
}
NetworkStats.LogInPacket(packet);
switch (packet.PacketType)
{
case PacketType.Voice:
case PacketType.VoiceWhisper:
LoggerRawVoice.Trace("[I] {0}", packet);
break;
case PacketType.Command:
LoggerRaw.Debug("[I] {0}", packet);
packet = ReceiveCommand(packet, receiveQueue, PacketType.Ack);
break;
case PacketType.CommandLow:
LoggerRaw.Debug("[I] {0}", packet);
packet = ReceiveCommand(packet, receiveQueueLow, PacketType.AckLow);
break;
case PacketType.Ping:
LoggerRaw.Trace("[I] Ping {0}", packet.PacketId);
ReceivePing(packet);
break;
case PacketType.Pong:
LoggerRaw.Trace("[I] Pong {0}", BinaryPrimitives.ReadUInt16BigEndian(packet.Data));
ReceivePong(packet);
break;
case PacketType.Ack:
LoggerRaw.Debug("[I] Acking: {0}", BinaryPrimitives.ReadUInt16BigEndian(packet.Data));
packet = ReceiveAck(packet);
break;
case PacketType.AckLow: break;
case PacketType.Init1:
if (!LoggerRaw.IsTraceEnabled)
{
LoggerRaw.Debug("[I] InitID: {0}", packet.Data[0]);
}
if (!LoggerRaw.IsDebugEnabled)
{
LoggerRaw.Trace("[I] {0}", packet);
}
ReceiveInitAck(packet);
break;
default: throw Util.UnhandledDefault(packet.PacketType);
}
if (packet != null)
{
return(packet);
}
}
}
