niko
1756 lines
53 KiB
C#
1756 lines
53 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using ExitGames.Client.Photon.EncryptorManaged;
|
|
|
|
namespace ExitGames.Client.Photon
|
|
{
|
|
// Token: 0x02000017 RID: 23
|
|
internal class EnetPeer : PeerBase
|
|
{
|
|
// Token: 0x1700005C RID: 92
|
|
// (get) Token: 0x0600014A RID: 330 RVA: 0x0000A930 File Offset: 0x00008B30
|
|
internal override int QueuedIncomingCommandsCount
|
|
{
|
|
get
|
|
{
|
|
int num = 0;
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
for (int i = 0; i < this.channelArray.Length; i++)
|
|
{
|
|
EnetChannel enetChannel = this.channelArray[i];
|
|
num += enetChannel.incomingReliableCommandsList.Count;
|
|
num += enetChannel.incomingUnreliableCommandsList.Count;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700005D RID: 93
|
|
// (get) Token: 0x0600014B RID: 331 RVA: 0x0000A9B4 File Offset: 0x00008BB4
|
|
internal override int QueuedOutgoingCommandsCount
|
|
{
|
|
get
|
|
{
|
|
int num = 0;
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
for (int i = 0; i < this.channelArray.Length; i++)
|
|
{
|
|
EnetChannel enetChannel = this.channelArray[i];
|
|
num += enetChannel.outgoingReliableCommandsList.Count;
|
|
num += enetChannel.outgoingUnreliableCommandsList.Count;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700005E RID: 94
|
|
// (get) Token: 0x0600014C RID: 332 RVA: 0x0000AA38 File Offset: 0x00008C38
|
|
private Encryptor encryptor
|
|
{
|
|
get
|
|
{
|
|
return this.ppeer.encryptor;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700005F RID: 95
|
|
// (get) Token: 0x0600014D RID: 333 RVA: 0x0000AA58 File Offset: 0x00008C58
|
|
private Decryptor decryptor
|
|
{
|
|
get
|
|
{
|
|
return this.ppeer.decryptor;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600014E RID: 334 RVA: 0x0000AA78 File Offset: 0x00008C78
|
|
internal EnetPeer()
|
|
{
|
|
PeerBase.peerCount += 1;
|
|
base.InitOnce();
|
|
this.TrafficPackageHeaderSize = 12;
|
|
}
|
|
|
|
// Token: 0x0600014F RID: 335 RVA: 0x0000AAE4 File Offset: 0x00008CE4
|
|
internal override void InitPeerBase()
|
|
{
|
|
base.InitPeerBase();
|
|
bool flag = this.ppeer.PayloadEncryptionSecret != null && this.usedProtocol == ConnectionProtocol.Udp;
|
|
if (flag)
|
|
{
|
|
this.InitEncryption(this.ppeer.PayloadEncryptionSecret);
|
|
}
|
|
bool flag2 = this.encryptor != null && this.decryptor != null;
|
|
if (flag2)
|
|
{
|
|
this.isEncryptionAvailable = true;
|
|
}
|
|
this.peerID = (this.ppeer.EnableServerTracing ? -2 : -1);
|
|
this.challenge = SupportClass.ThreadSafeRandom.Next();
|
|
bool flag3 = this.udpBuffer == null || this.udpBuffer.Length != base.mtu;
|
|
if (flag3)
|
|
{
|
|
this.udpBuffer = new byte[base.mtu];
|
|
}
|
|
this.reliableCommandsSent = 0;
|
|
this.reliableCommandsRepeated = 0;
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
EnetChannel[] array2 = this.channelArray;
|
|
bool flag4 = array2.Length != (int)(base.ChannelCount + 1);
|
|
if (flag4)
|
|
{
|
|
array2 = new EnetChannel[(int)(base.ChannelCount + 1)];
|
|
}
|
|
for (byte b = 0; b < base.ChannelCount; b += 1)
|
|
{
|
|
array2[(int)b] = new EnetChannel(b, this.commandBufferSize);
|
|
}
|
|
array2[(int)base.ChannelCount] = new EnetChannel(byte.MaxValue, this.commandBufferSize);
|
|
this.channelArray = array2;
|
|
}
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
this.sentReliableCommands = new List<NCommand>(this.commandBufferSize);
|
|
}
|
|
this.outgoingAcknowledgementsPool = new StreamBuffer(0);
|
|
base.CommandLogInit();
|
|
}
|
|
|
|
// Token: 0x06000150 RID: 336 RVA: 0x0000ACAC File Offset: 0x00008EAC
|
|
internal override bool Connect(string ipport, string appID, object custom = null)
|
|
{
|
|
bool flag = this.peerConnectionState > PeerBase.ConnectionStateValue.Disconnected;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.WARNING, "Connect() can't be called if peer is not Disconnected. Not connecting. peerConnectionState: " + this.peerConnectionState);
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = base.debugOut >= DebugLevel.ALL;
|
|
if (flag3)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ALL, "Connect()");
|
|
}
|
|
base.ServerAddress = ipport;
|
|
this.InitPeerBase();
|
|
bool flag4 = base.SocketImplementation != null;
|
|
if (flag4)
|
|
{
|
|
this.rt = (IPhotonSocket)Activator.CreateInstance(base.SocketImplementation, new object[] { this });
|
|
}
|
|
else
|
|
{
|
|
this.rt = new SocketUdp(this);
|
|
}
|
|
bool flag5 = this.rt == null;
|
|
if (flag5)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, "Connect() failed, because SocketImplementation or socket was null. Set PhotonPeer.SocketImplementation before Connect().");
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag6 = this.rt.Connect();
|
|
if (flag6)
|
|
{
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
base.TrafficStatsOutgoing.ControlCommandBytes += 44;
|
|
base.TrafficStatsOutgoing.ControlCommandCount++;
|
|
}
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Connecting;
|
|
flag2 = true;
|
|
}
|
|
else
|
|
{
|
|
flag2 = false;
|
|
}
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x06000151 RID: 337 RVA: 0x0000ADE2 File Offset: 0x00008FE2
|
|
public override void OnConnect()
|
|
{
|
|
this.QueueOutgoingReliableCommand(new NCommand(this, 2, null, byte.MaxValue));
|
|
}
|
|
|
|
// Token: 0x06000152 RID: 338 RVA: 0x0000ADFC File Offset: 0x00008FFC
|
|
internal override void Disconnect()
|
|
{
|
|
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected || this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnecting;
|
|
if (!flag)
|
|
{
|
|
bool flag2 = this.sentReliableCommands != null;
|
|
if (flag2)
|
|
{
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
this.sentReliableCommands.Clear();
|
|
}
|
|
}
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
foreach (EnetChannel enetChannel in this.channelArray)
|
|
{
|
|
enetChannel.clearAll();
|
|
}
|
|
}
|
|
bool isSimulationEnabled = base.NetworkSimulationSettings.IsSimulationEnabled;
|
|
base.NetworkSimulationSettings.IsSimulationEnabled = false;
|
|
NCommand ncommand = new NCommand(this, 4, null, byte.MaxValue);
|
|
this.QueueOutgoingReliableCommand(ncommand);
|
|
this.SendOutgoingCommands();
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
base.TrafficStatsOutgoing.CountControlCommand(ncommand.Size);
|
|
}
|
|
base.NetworkSimulationSettings.IsSimulationEnabled = isSimulationEnabled;
|
|
this.rt.Disconnect();
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnected;
|
|
base.EnqueueStatusCallback(StatusCode.Disconnect);
|
|
this.datagramEncryptedConnection = false;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000153 RID: 339 RVA: 0x0000AF50 File Offset: 0x00009150
|
|
internal override void StopConnection()
|
|
{
|
|
bool flag = this.rt != null;
|
|
if (flag)
|
|
{
|
|
this.rt.Disconnect();
|
|
}
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnected;
|
|
bool flag2 = base.Listener != null;
|
|
if (flag2)
|
|
{
|
|
base.Listener.OnStatusChanged(StatusCode.Disconnect);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000154 RID: 340 RVA: 0x0000AFA0 File Offset: 0x000091A0
|
|
internal override void FetchServerTimestamp()
|
|
{
|
|
bool flag = this.peerConnectionState != PeerBase.ConnectionStateValue.Connected || !this.ApplicationIsInitialized;
|
|
if (flag)
|
|
{
|
|
bool flag2 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag2)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.INFO, "FetchServerTimestamp() was skipped, as the client is not connected. Current ConnectionState: " + this.peerConnectionState);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.CreateAndEnqueueCommand(12, new byte[0], byte.MaxValue);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000155 RID: 341 RVA: 0x0000B010 File Offset: 0x00009210
|
|
internal override bool DispatchIncomingCommands()
|
|
{
|
|
for (;;)
|
|
{
|
|
Queue<PeerBase.MyAction> actionQueue = this.ActionQueue;
|
|
PeerBase.MyAction myAction;
|
|
lock (actionQueue)
|
|
{
|
|
bool flag = this.ActionQueue.Count <= 0;
|
|
if (flag)
|
|
{
|
|
break;
|
|
}
|
|
myAction = this.ActionQueue.Dequeue();
|
|
}
|
|
myAction();
|
|
}
|
|
NCommand ncommand = null;
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
for (int i = 0; i < this.channelArray.Length; i++)
|
|
{
|
|
EnetChannel enetChannel = this.channelArray[i];
|
|
bool flag2 = enetChannel.incomingUnreliableCommandsList.Count > 0;
|
|
if (flag2)
|
|
{
|
|
int num = int.MaxValue;
|
|
foreach (int num2 in enetChannel.incomingUnreliableCommandsList.Keys)
|
|
{
|
|
NCommand ncommand2 = enetChannel.incomingUnreliableCommandsList[num2];
|
|
bool flag3 = num2 < enetChannel.incomingUnreliableSequenceNumber || ncommand2.reliableSequenceNumber < enetChannel.incomingReliableSequenceNumber;
|
|
if (flag3)
|
|
{
|
|
this.commandsToRemove.Enqueue(num2);
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = base.limitOfUnreliableCommands > 0 && enetChannel.incomingUnreliableCommandsList.Count > base.limitOfUnreliableCommands;
|
|
if (flag4)
|
|
{
|
|
this.commandsToRemove.Enqueue(num2);
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = num2 < num;
|
|
if (flag5)
|
|
{
|
|
bool flag6 = ncommand2.reliableSequenceNumber > enetChannel.incomingReliableSequenceNumber;
|
|
if (!flag6)
|
|
{
|
|
num = num2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (this.commandsToRemove.Count > 0)
|
|
{
|
|
enetChannel.incomingUnreliableCommandsList.Remove(this.commandsToRemove.Dequeue());
|
|
}
|
|
bool flag7 = num < int.MaxValue;
|
|
if (flag7)
|
|
{
|
|
ncommand = enetChannel.incomingUnreliableCommandsList[num];
|
|
}
|
|
bool flag8 = ncommand != null;
|
|
if (flag8)
|
|
{
|
|
enetChannel.incomingUnreliableCommandsList.Remove(ncommand.unreliableSequenceNumber);
|
|
enetChannel.incomingUnreliableSequenceNumber = ncommand.unreliableSequenceNumber;
|
|
break;
|
|
}
|
|
}
|
|
bool flag9 = ncommand == null && enetChannel.incomingReliableCommandsList.Count > 0;
|
|
if (flag9)
|
|
{
|
|
enetChannel.incomingReliableCommandsList.TryGetValue(enetChannel.incomingReliableSequenceNumber + 1, out ncommand);
|
|
bool flag10 = ncommand == null;
|
|
if (!flag10)
|
|
{
|
|
bool flag11 = ncommand.commandType != 8;
|
|
if (flag11)
|
|
{
|
|
enetChannel.incomingReliableSequenceNumber = ncommand.reliableSequenceNumber;
|
|
enetChannel.incomingReliableCommandsList.Remove(ncommand.reliableSequenceNumber);
|
|
break;
|
|
}
|
|
bool flag12 = ncommand.fragmentsRemaining > 0;
|
|
if (flag12)
|
|
{
|
|
ncommand = null;
|
|
}
|
|
else
|
|
{
|
|
byte[] array2 = new byte[ncommand.totalLength];
|
|
for (int j = ncommand.startSequenceNumber; j < ncommand.startSequenceNumber + ncommand.fragmentCount; j++)
|
|
{
|
|
bool flag13 = enetChannel.ContainsReliableSequenceNumber(j);
|
|
if (!flag13)
|
|
{
|
|
throw new Exception("command.fragmentsRemaining was 0, but not all fragments are found to be combined!");
|
|
}
|
|
NCommand ncommand3 = enetChannel.FetchReliableSequenceNumber(j);
|
|
Buffer.BlockCopy(ncommand3.Payload, 0, array2, ncommand3.fragmentOffset, ncommand3.Payload.Length);
|
|
enetChannel.incomingReliableCommandsList.Remove(ncommand3.reliableSequenceNumber);
|
|
}
|
|
bool flag14 = base.debugOut >= DebugLevel.ALL;
|
|
if (flag14)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ALL, "assembled fragmented payload from " + ncommand.fragmentCount + " parts. Dispatching now.");
|
|
}
|
|
ncommand.Payload = array2;
|
|
ncommand.Size = 12 * ncommand.fragmentCount + ncommand.totalLength;
|
|
enetChannel.incomingReliableSequenceNumber = ncommand.reliableSequenceNumber + ncommand.fragmentCount - 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool flag15 = ncommand != null && ncommand.Payload != null;
|
|
if (flag15)
|
|
{
|
|
this.ByteCountCurrentDispatch = ncommand.Size;
|
|
this.CommandInCurrentDispatch = ncommand;
|
|
bool flag16 = this.DeserializeMessageAndCallback(ncommand.Payload);
|
|
if (flag16)
|
|
{
|
|
this.CommandInCurrentDispatch = null;
|
|
return true;
|
|
}
|
|
this.CommandInCurrentDispatch = null;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x06000156 RID: 342 RVA: 0x0000B488 File Offset: 0x00009688
|
|
private int GetFragmentLength()
|
|
{
|
|
int num = base.mtu;
|
|
bool flag = this.datagramEncryptedConnection;
|
|
int num2;
|
|
if (flag)
|
|
{
|
|
num = num - 7 - EnetPeer.HMAC_SIZE - EnetPeer.IV_SIZE;
|
|
num = num / EnetPeer.BLOCK_SIZE * EnetPeer.BLOCK_SIZE;
|
|
num = num - 5 - 36;
|
|
num2 = num;
|
|
}
|
|
else
|
|
{
|
|
num2 = num - 12 - 36;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000157 RID: 343 RVA: 0x0000B4DC File Offset: 0x000096DC
|
|
private int CalculateBufferLen()
|
|
{
|
|
int num = base.mtu;
|
|
bool flag = this.datagramEncryptedConnection;
|
|
int num2;
|
|
if (flag)
|
|
{
|
|
num = num - 7 - EnetPeer.HMAC_SIZE - EnetPeer.IV_SIZE;
|
|
num = num / EnetPeer.BLOCK_SIZE * EnetPeer.BLOCK_SIZE;
|
|
num--;
|
|
num2 = num;
|
|
}
|
|
else
|
|
{
|
|
num2 = num;
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x06000158 RID: 344 RVA: 0x0000B528 File Offset: 0x00009728
|
|
private int CalculateInitialOffset()
|
|
{
|
|
bool flag = this.datagramEncryptedConnection;
|
|
int num;
|
|
if (flag)
|
|
{
|
|
num = 5;
|
|
}
|
|
else
|
|
{
|
|
int num2 = 12;
|
|
bool crcEnabled = base.crcEnabled;
|
|
if (crcEnabled)
|
|
{
|
|
num2 += 4;
|
|
}
|
|
num = num2;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000159 RID: 345 RVA: 0x0000B560 File Offset: 0x00009760
|
|
internal override bool SendAcksOnly()
|
|
{
|
|
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = this.rt == null || !this.rt.Connected;
|
|
if (flag3)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
byte[] array = this.udpBuffer;
|
|
lock (array)
|
|
{
|
|
int num = 0;
|
|
this.udpBufferIndex = this.CalculateInitialOffset();
|
|
this.udpBufferLength = this.CalculateBufferLen();
|
|
this.udpCommandCount = 0;
|
|
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
|
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
|
lock (streamBuffer)
|
|
{
|
|
num = this.SerializeAckToBuffer();
|
|
this.timeLastSendAck = this.timeInt;
|
|
}
|
|
bool flag4 = this.timeInt > this.timeoutInt && this.sentReliableCommands.Count > 0;
|
|
if (flag4)
|
|
{
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
foreach (NCommand ncommand in this.sentReliableCommands)
|
|
{
|
|
bool flag5 = ncommand != null && ncommand.roundTripTimeout != 0 && this.timeInt - ncommand.commandSentTime > ncommand.roundTripTimeout;
|
|
if (flag5)
|
|
{
|
|
ncommand.commandSentCount = 1;
|
|
ncommand.roundTripTimeout = 0;
|
|
ncommand.timeoutTime = int.MaxValue;
|
|
ncommand.commandSentTime = this.timeInt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool flag6 = this.udpCommandCount <= 0;
|
|
if (flag6)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
TrafficStats trafficStatsOutgoing = base.TrafficStatsOutgoing;
|
|
int totalPacketCount = trafficStatsOutgoing.TotalPacketCount;
|
|
trafficStatsOutgoing.TotalPacketCount = totalPacketCount + 1;
|
|
base.TrafficStatsOutgoing.TotalCommandsInPackets += (int)this.udpCommandCount;
|
|
}
|
|
this.SendData(this.udpBuffer, this.udpBufferIndex);
|
|
flag2 = num > 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x0600015A RID: 346 RVA: 0x0000B7D0 File Offset: 0x000099D0
|
|
internal override bool SendOutgoingCommands()
|
|
{
|
|
bool flag = this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnected;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = !this.rt.Connected;
|
|
if (flag3)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
byte[] array = this.udpBuffer;
|
|
lock (array)
|
|
{
|
|
int num = 0;
|
|
this.udpBufferIndex = this.CalculateInitialOffset();
|
|
this.udpBufferLength = this.CalculateBufferLen();
|
|
this.udpCommandCount = 0;
|
|
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
|
this.timeLastSendOutgoing = this.timeInt;
|
|
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
|
lock (streamBuffer)
|
|
{
|
|
bool flag4 = this.outgoingAcknowledgementsPool.Length > 0L;
|
|
if (flag4)
|
|
{
|
|
num = this.SerializeAckToBuffer();
|
|
this.timeLastSendAck = this.timeInt;
|
|
}
|
|
}
|
|
bool flag5 = !base.IsSendingOnlyAcks && this.timeInt > this.timeoutInt && this.sentReliableCommands.Count > 0;
|
|
if (flag5)
|
|
{
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
this.commandsToResend.Clear();
|
|
foreach (NCommand ncommand in this.sentReliableCommands)
|
|
{
|
|
bool flag6 = ncommand != null && this.timeInt - ncommand.commandSentTime > ncommand.roundTripTimeout;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = (int)ncommand.commandSentCount > base.sentCountAllowance || this.timeInt > ncommand.timeoutTime;
|
|
if (flag7)
|
|
{
|
|
bool flag8 = base.debugOut >= DebugLevel.WARNING;
|
|
if (flag8)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.WARNING, string.Concat(new object[]
|
|
{
|
|
"Timeout-disconnect! Command: ",
|
|
ncommand,
|
|
" now: ",
|
|
this.timeInt,
|
|
" challenge: ",
|
|
Convert.ToString(this.challenge, 16)
|
|
}));
|
|
}
|
|
bool flag9 = this.CommandLog != null;
|
|
if (flag9)
|
|
{
|
|
this.CommandLog.Enqueue(new CmdLogSentReliable(ncommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, true));
|
|
base.CommandLogResize();
|
|
}
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Zombie;
|
|
base.Listener.OnStatusChanged(StatusCode.TimeoutDisconnect);
|
|
this.Disconnect();
|
|
return false;
|
|
}
|
|
this.commandsToResend.Enqueue(ncommand);
|
|
}
|
|
}
|
|
while (this.commandsToResend.Count > 0)
|
|
{
|
|
NCommand ncommand2 = this.commandsToResend.Dequeue();
|
|
this.QueueOutgoingReliableCommand(ncommand2);
|
|
this.sentReliableCommands.Remove(ncommand2);
|
|
this.reliableCommandsRepeated++;
|
|
bool flag10 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag10)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Format("Resending: {0}. times out after: {1} sent: {3} now: {2} rtt/var: {4}/{5} last recv: {6}", new object[]
|
|
{
|
|
ncommand2,
|
|
ncommand2.roundTripTimeout,
|
|
this.timeInt,
|
|
ncommand2.commandSentTime,
|
|
this.roundTripTime,
|
|
this.roundTripTimeVariance,
|
|
SupportClass.GetTickCount() - this.timestampOfLastReceive
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool flag11 = !base.IsSendingOnlyAcks && this.peerConnectionState == PeerBase.ConnectionStateValue.Connected && base.timePingInterval > 0 && this.sentReliableCommands.Count == 0 && this.timeInt - this.timeLastAckReceive > base.timePingInterval && !this.AreReliableCommandsInTransit() && this.udpBufferIndex + 12 < this.udpBufferLength;
|
|
if (flag11)
|
|
{
|
|
NCommand ncommand3 = new NCommand(this, 5, null, byte.MaxValue);
|
|
this.QueueOutgoingReliableCommand(ncommand3);
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
base.TrafficStatsOutgoing.CountControlCommand(ncommand3.Size);
|
|
}
|
|
}
|
|
bool flag12 = !base.IsSendingOnlyAcks;
|
|
if (flag12)
|
|
{
|
|
EnetChannel[] array2 = this.channelArray;
|
|
lock (array2)
|
|
{
|
|
for (int i = 0; i < this.channelArray.Length; i++)
|
|
{
|
|
EnetChannel enetChannel = this.channelArray[i];
|
|
num += this.SerializeToBuffer(enetChannel.outgoingReliableCommandsList);
|
|
num += this.SerializeToBuffer(enetChannel.outgoingUnreliableCommandsList);
|
|
}
|
|
}
|
|
}
|
|
bool flag13 = this.udpCommandCount <= 0;
|
|
if (flag13)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled2)
|
|
{
|
|
TrafficStats trafficStatsOutgoing = base.TrafficStatsOutgoing;
|
|
int totalPacketCount = trafficStatsOutgoing.TotalPacketCount;
|
|
trafficStatsOutgoing.TotalPacketCount = totalPacketCount + 1;
|
|
base.TrafficStatsOutgoing.TotalCommandsInPackets += (int)this.udpCommandCount;
|
|
}
|
|
this.SendData(this.udpBuffer, this.udpBufferIndex);
|
|
flag2 = num > 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x0600015B RID: 347 RVA: 0x0000BD58 File Offset: 0x00009F58
|
|
private bool AreReliableCommandsInTransit()
|
|
{
|
|
EnetChannel[] array = this.channelArray;
|
|
lock (array)
|
|
{
|
|
for (int i = 0; i < this.channelArray.Length; i++)
|
|
{
|
|
EnetChannel enetChannel = this.channelArray[i];
|
|
bool flag = enetChannel.outgoingReliableCommandsList.Count > 0;
|
|
if (flag)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x0600015C RID: 348 RVA: 0x0000BDD4 File Offset: 0x00009FD4
|
|
internal override bool EnqueueOperation(Dictionary<byte, object> parameters, byte opCode, bool sendReliable, byte channelId, bool encrypt, PeerBase.EgMessageType messageType)
|
|
{
|
|
bool flag = this.peerConnectionState != PeerBase.ConnectionStateValue.Connected;
|
|
bool flag3;
|
|
if (flag)
|
|
{
|
|
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag2)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "Cannot send op: ", opCode, " Not connected. PeerState: ", this.peerConnectionState }));
|
|
}
|
|
base.Listener.OnStatusChanged(StatusCode.SendError);
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = channelId >= base.ChannelCount;
|
|
if (flag4)
|
|
{
|
|
bool flag5 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag5)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "Cannot send op: Selected channel (", channelId, ")>= channelCount (", base.ChannelCount, ")." }));
|
|
}
|
|
base.Listener.OnStatusChanged(StatusCode.SendError);
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
byte[] array = this.SerializeOperationToMessage(opCode, parameters, messageType, encrypt);
|
|
flag3 = this.CreateAndEnqueueCommand(sendReliable ? 6 : 7, array, channelId);
|
|
}
|
|
}
|
|
return flag3;
|
|
}
|
|
|
|
// Token: 0x0600015D RID: 349 RVA: 0x0000BF04 File Offset: 0x0000A104
|
|
private EnetChannel GetChannel(byte channelNumber)
|
|
{
|
|
return (channelNumber == byte.MaxValue) ? this.channelArray[this.channelArray.Length - 1] : this.channelArray[(int)channelNumber];
|
|
}
|
|
|
|
// Token: 0x0600015E RID: 350 RVA: 0x0000BF3C File Offset: 0x0000A13C
|
|
internal bool CreateAndEnqueueCommand(byte commandType, byte[] payload, byte channelNumber)
|
|
{
|
|
bool flag = payload == null;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
EnetChannel channel = this.GetChannel(channelNumber);
|
|
this.ByteCountLastOperation = 0;
|
|
int num = this.GetFragmentLength();
|
|
bool flag3 = payload.Length > num;
|
|
if (flag3)
|
|
{
|
|
int num2 = (payload.Length + num - 1) / num;
|
|
int num3 = channel.outgoingReliableSequenceNumber + 1;
|
|
int num4 = 0;
|
|
for (int i = 0; i < payload.Length; i += num)
|
|
{
|
|
bool flag4 = payload.Length - i < num;
|
|
if (flag4)
|
|
{
|
|
num = payload.Length - i;
|
|
}
|
|
byte[] array = new byte[num];
|
|
Buffer.BlockCopy(payload, i, array, 0, num);
|
|
NCommand ncommand = new NCommand(this, 8, array, channel.ChannelNumber);
|
|
ncommand.fragmentNumber = num4;
|
|
ncommand.startSequenceNumber = num3;
|
|
ncommand.fragmentCount = num2;
|
|
ncommand.totalLength = payload.Length;
|
|
ncommand.fragmentOffset = i;
|
|
this.QueueOutgoingReliableCommand(ncommand);
|
|
this.ByteCountLastOperation += ncommand.Size;
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
base.TrafficStatsOutgoing.CountFragmentOpCommand(ncommand.Size);
|
|
base.TrafficStatsGameLevel.CountOperation(ncommand.Size);
|
|
}
|
|
num4++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NCommand ncommand2 = new NCommand(this, commandType, payload, channel.ChannelNumber);
|
|
bool flag5 = ncommand2.commandFlags == 1;
|
|
if (flag5)
|
|
{
|
|
this.QueueOutgoingReliableCommand(ncommand2);
|
|
this.ByteCountLastOperation = ncommand2.Size;
|
|
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled2)
|
|
{
|
|
base.TrafficStatsOutgoing.CountReliableOpCommand(ncommand2.Size);
|
|
base.TrafficStatsGameLevel.CountOperation(ncommand2.Size);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.QueueOutgoingUnreliableCommand(ncommand2);
|
|
this.ByteCountLastOperation = ncommand2.Size;
|
|
bool trafficStatsEnabled3 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled3)
|
|
{
|
|
base.TrafficStatsOutgoing.CountUnreliableOpCommand(ncommand2.Size);
|
|
base.TrafficStatsGameLevel.CountOperation(ncommand2.Size);
|
|
}
|
|
}
|
|
}
|
|
flag2 = true;
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x0600015F RID: 351 RVA: 0x0000C144 File Offset: 0x0000A344
|
|
internal override byte[] SerializeOperationToMessage(byte opCode, Dictionary<byte, object> parameters, PeerBase.EgMessageType messageType, bool encrypt)
|
|
{
|
|
encrypt = encrypt && !this.datagramEncryptedConnection;
|
|
StreamBuffer serializeMemStream = this.SerializeMemStream;
|
|
byte[] array2;
|
|
lock (serializeMemStream)
|
|
{
|
|
this.SerializeMemStream.SetLength(0L);
|
|
bool flag = !encrypt;
|
|
if (flag)
|
|
{
|
|
this.SerializeMemStream.Write(EnetPeer.messageHeader, 0, EnetPeer.messageHeader.Length);
|
|
}
|
|
this.protocol.SerializeOperationRequest(this.SerializeMemStream, opCode, parameters, false);
|
|
bool flag2 = encrypt;
|
|
if (flag2)
|
|
{
|
|
byte[] array = this.CryptoProvider.Encrypt(this.SerializeMemStream.GetBuffer(), 0, (int)this.SerializeMemStream.Length);
|
|
this.SerializeMemStream.SetLength(0L);
|
|
this.SerializeMemStream.Write(EnetPeer.messageHeader, 0, EnetPeer.messageHeader.Length);
|
|
this.SerializeMemStream.Write(array, 0, array.Length);
|
|
}
|
|
array2 = this.SerializeMemStream.ToArray();
|
|
}
|
|
bool flag3 = messageType != PeerBase.EgMessageType.Operation;
|
|
if (flag3)
|
|
{
|
|
array2[EnetPeer.messageHeader.Length - 1] = (byte)messageType;
|
|
}
|
|
bool flag4 = encrypt;
|
|
if (flag4)
|
|
{
|
|
array2[EnetPeer.messageHeader.Length - 1] = array2[EnetPeer.messageHeader.Length - 1] | 128;
|
|
}
|
|
return array2;
|
|
}
|
|
|
|
// Token: 0x06000160 RID: 352 RVA: 0x0000C294 File Offset: 0x0000A494
|
|
internal int SerializeAckToBuffer()
|
|
{
|
|
this.outgoingAcknowledgementsPool.Seek(0L, SeekOrigin.Begin);
|
|
while (this.outgoingAcknowledgementsPool.Position + 20L <= this.outgoingAcknowledgementsPool.Length)
|
|
{
|
|
bool flag = this.udpBufferIndex + 20 > this.udpBufferLength;
|
|
if (flag)
|
|
{
|
|
bool flag2 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag2)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
|
{
|
|
"UDP package is full. Commands in Package: ",
|
|
this.udpCommandCount,
|
|
". bytes left in queue: ",
|
|
this.outgoingAcknowledgementsPool.Position
|
|
}));
|
|
}
|
|
break;
|
|
}
|
|
int num;
|
|
byte[] bufferAndAdvance = this.outgoingAcknowledgementsPool.GetBufferAndAdvance(20, out num);
|
|
Buffer.BlockCopy(bufferAndAdvance, num, this.udpBuffer, this.udpBufferIndex, 20);
|
|
this.udpBufferIndex += 20;
|
|
this.udpCommandCount += 1;
|
|
}
|
|
this.outgoingAcknowledgementsPool.Compact();
|
|
this.outgoingAcknowledgementsPool.Position = this.outgoingAcknowledgementsPool.Length;
|
|
return (int)this.outgoingAcknowledgementsPool.Length / 20;
|
|
}
|
|
|
|
// Token: 0x06000161 RID: 353 RVA: 0x0000C3D0 File Offset: 0x0000A5D0
|
|
internal int SerializeToBuffer(Queue<NCommand> commandList)
|
|
{
|
|
while (commandList.Count > 0)
|
|
{
|
|
NCommand ncommand = commandList.Peek();
|
|
bool flag = ncommand == null;
|
|
if (flag)
|
|
{
|
|
commandList.Dequeue();
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = this.udpBufferIndex + ncommand.Size > this.udpBufferLength;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag3)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[] { "UDP package is full. Commands in Package: ", this.udpCommandCount, ". Commands left in queue: ", commandList.Count }));
|
|
}
|
|
break;
|
|
}
|
|
ncommand.SerializeHeader(this.udpBuffer, ref this.udpBufferIndex);
|
|
bool flag4 = ncommand.SizeOfPayload > 0;
|
|
if (flag4)
|
|
{
|
|
Buffer.BlockCopy(ncommand.Serialize(), 0, this.udpBuffer, this.udpBufferIndex, ncommand.SizeOfPayload);
|
|
this.udpBufferIndex += ncommand.SizeOfPayload;
|
|
}
|
|
this.udpCommandCount += 1;
|
|
bool flag5 = (ncommand.commandFlags & 1) > 0;
|
|
if (flag5)
|
|
{
|
|
this.QueueSentCommand(ncommand);
|
|
bool flag6 = this.CommandLog != null;
|
|
if (flag6)
|
|
{
|
|
this.CommandLog.Enqueue(new CmdLogSentReliable(ncommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, false));
|
|
base.CommandLogResize();
|
|
}
|
|
}
|
|
commandList.Dequeue();
|
|
}
|
|
}
|
|
return commandList.Count;
|
|
}
|
|
|
|
// Token: 0x06000162 RID: 354 RVA: 0x0000C558 File Offset: 0x0000A758
|
|
internal void SendData(byte[] data, int length)
|
|
{
|
|
try
|
|
{
|
|
bool flag = this.datagramEncryptedConnection;
|
|
if (flag)
|
|
{
|
|
this.SendDataEncrypted(data, length);
|
|
}
|
|
else
|
|
{
|
|
int num = 0;
|
|
Protocol.Serialize(this.peerID, data, ref num);
|
|
data[2] = (base.crcEnabled ? 204 : 0);
|
|
data[3] = this.udpCommandCount;
|
|
num = 4;
|
|
Protocol.Serialize(this.timeInt, data, ref num);
|
|
Protocol.Serialize(this.challenge, data, ref num);
|
|
bool crcEnabled = base.crcEnabled;
|
|
if (crcEnabled)
|
|
{
|
|
Protocol.Serialize(0, data, ref num);
|
|
uint num2 = SupportClass.CalculateCrc(data, length);
|
|
num -= 4;
|
|
Protocol.Serialize((int)num2, data, ref num);
|
|
}
|
|
this.bytesOut += (long)length;
|
|
this.SendToSocket(data, length);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag2)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, ex.ToString());
|
|
}
|
|
SupportClass.WriteStackTrace(ex);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000163 RID: 355 RVA: 0x0000C65C File Offset: 0x0000A85C
|
|
private void SendToSocket(byte[] data, int length)
|
|
{
|
|
bool isSimulationEnabled = base.NetworkSimulationSettings.IsSimulationEnabled;
|
|
if (isSimulationEnabled)
|
|
{
|
|
byte[] array = new byte[length];
|
|
Buffer.BlockCopy(data, 0, array, 0, length);
|
|
base.SendNetworkSimulated(array);
|
|
}
|
|
else
|
|
{
|
|
this.rt.Send(data, length);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000164 RID: 356 RVA: 0x0000C6A8 File Offset: 0x0000A8A8
|
|
private void SendDataEncrypted(byte[] data, int length)
|
|
{
|
|
bool flag = this.bufferForEncryption == null || this.bufferForEncryption.Length != base.mtu;
|
|
if (flag)
|
|
{
|
|
this.bufferForEncryption = new byte[base.mtu];
|
|
}
|
|
byte[] array = this.bufferForEncryption;
|
|
int num = 0;
|
|
Protocol.Serialize(this.peerID, array, ref num);
|
|
array[2] = 1;
|
|
num++;
|
|
Protocol.Serialize(this.challenge, array, ref num);
|
|
data[0] = this.udpCommandCount;
|
|
int num2 = 1;
|
|
Protocol.Serialize(this.timeInt, data, ref num2);
|
|
this.encryptor.Encrypt(data, length, array, ref num);
|
|
Buffer.BlockCopy(this.encryptor.FinishHMAC(array, 0, num), 0, array, num, EnetPeer.HMAC_SIZE);
|
|
this.SendToSocket(array, num + EnetPeer.HMAC_SIZE);
|
|
}
|
|
|
|
// Token: 0x06000165 RID: 357 RVA: 0x0000C770 File Offset: 0x0000A970
|
|
internal void QueueSentCommand(NCommand command)
|
|
{
|
|
command.commandSentTime = this.timeInt;
|
|
command.commandSentCount += 1;
|
|
bool flag = command.roundTripTimeout == 0;
|
|
if (flag)
|
|
{
|
|
command.roundTripTimeout = this.roundTripTime + 4 * this.roundTripTimeVariance;
|
|
command.timeoutTime = this.timeInt + base.DisconnectTimeout;
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = command.commandSentCount <= base.QuickResendAttempts + 1;
|
|
if (!flag2)
|
|
{
|
|
command.roundTripTimeout *= 2;
|
|
}
|
|
}
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
bool flag3 = this.sentReliableCommands.Count == 0;
|
|
if (flag3)
|
|
{
|
|
int num = command.commandSentTime + command.roundTripTimeout;
|
|
bool flag4 = num < this.timeoutInt;
|
|
if (flag4)
|
|
{
|
|
this.timeoutInt = num;
|
|
}
|
|
}
|
|
this.reliableCommandsSent++;
|
|
this.sentReliableCommands.Add(command);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000166 RID: 358 RVA: 0x0000C884 File Offset: 0x0000AA84
|
|
internal void QueueOutgoingReliableCommand(NCommand command)
|
|
{
|
|
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
|
EnetChannel enetChannel = channel;
|
|
lock (enetChannel)
|
|
{
|
|
bool flag = command.reliableSequenceNumber == 0;
|
|
if (flag)
|
|
{
|
|
EnetChannel enetChannel2 = channel;
|
|
int num = enetChannel2.outgoingReliableSequenceNumber + 1;
|
|
enetChannel2.outgoingReliableSequenceNumber = num;
|
|
command.reliableSequenceNumber = num;
|
|
}
|
|
channel.outgoingReliableCommandsList.Enqueue(command);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000167 RID: 359 RVA: 0x0000C8F8 File Offset: 0x0000AAF8
|
|
internal void QueueOutgoingUnreliableCommand(NCommand command)
|
|
{
|
|
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
|
EnetChannel enetChannel = channel;
|
|
lock (enetChannel)
|
|
{
|
|
command.reliableSequenceNumber = channel.outgoingReliableSequenceNumber;
|
|
EnetChannel enetChannel2 = channel;
|
|
int num = enetChannel2.outgoingUnreliableSequenceNumber + 1;
|
|
enetChannel2.outgoingUnreliableSequenceNumber = num;
|
|
command.unreliableSequenceNumber = num;
|
|
channel.outgoingUnreliableCommandsList.Enqueue(command);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000168 RID: 360 RVA: 0x0000C968 File Offset: 0x0000AB68
|
|
internal void QueueOutgoingAcknowledgement(NCommand readCommand, int sendTime)
|
|
{
|
|
StreamBuffer streamBuffer = this.outgoingAcknowledgementsPool;
|
|
lock (streamBuffer)
|
|
{
|
|
int num;
|
|
byte[] bufferAndAdvance = this.outgoingAcknowledgementsPool.GetBufferAndAdvance(20, out num);
|
|
NCommand.CreateAck(bufferAndAdvance, num, readCommand, sendTime);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000169 RID: 361 RVA: 0x0000C9BC File Offset: 0x0000ABBC
|
|
internal override void ReceiveIncomingCommands(byte[] inBuff, int dataLength)
|
|
{
|
|
this.timestampOfLastReceive = SupportClass.GetTickCount();
|
|
try
|
|
{
|
|
int num = 0;
|
|
short num2;
|
|
Protocol.Deserialize(out num2, inBuff, ref num);
|
|
byte b = inBuff[num++];
|
|
bool flag = b == 1;
|
|
int num3;
|
|
byte b2;
|
|
if (flag)
|
|
{
|
|
bool flag2 = this.decryptor == null;
|
|
if (flag2)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.ERROR, "Got encrypted packet, but encryption is not set up. Packet ignored");
|
|
return;
|
|
}
|
|
this.datagramEncryptedConnection = true;
|
|
bool flag3 = !this.decryptor.CheckHMAC(inBuff, dataLength);
|
|
if (flag3)
|
|
{
|
|
this.packetLossByCrc++;
|
|
bool flag4 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.INFO;
|
|
if (flag4)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.INFO, "Ignored package due to wrong HMAC.");
|
|
}
|
|
return;
|
|
}
|
|
Protocol.Deserialize(out num3, inBuff, ref num);
|
|
inBuff = this.decryptor.DecryptBufferWithIV(inBuff, num, dataLength - num - EnetPeer.HMAC_SIZE, out dataLength);
|
|
dataLength = inBuff.Length;
|
|
num = 0;
|
|
b2 = inBuff[num++];
|
|
Protocol.Deserialize(out this.serverSentTime, inBuff, ref num);
|
|
this.bytesIn += (long)(12 + EnetPeer.IV_SIZE + EnetPeer.HMAC_SIZE + dataLength + (EnetPeer.BLOCK_SIZE - dataLength % EnetPeer.BLOCK_SIZE));
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = this.datagramEncryptedConnection;
|
|
if (flag5)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.WARNING, "Got not encrypted packet, but expected only encrypted. Packet ignored");
|
|
return;
|
|
}
|
|
b2 = inBuff[num++];
|
|
Protocol.Deserialize(out this.serverSentTime, inBuff, ref num);
|
|
Protocol.Deserialize(out num3, inBuff, ref num);
|
|
bool flag6 = b == 204;
|
|
if (flag6)
|
|
{
|
|
int num4;
|
|
Protocol.Deserialize(out num4, inBuff, ref num);
|
|
this.bytesIn += 4L;
|
|
num -= 4;
|
|
Protocol.Serialize(0, inBuff, ref num);
|
|
uint num5 = SupportClass.CalculateCrc(inBuff, dataLength);
|
|
bool flag7 = num4 != (int)num5;
|
|
if (flag7)
|
|
{
|
|
this.packetLossByCrc++;
|
|
bool flag8 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.INFO;
|
|
if (flag8)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.INFO, string.Format("Ignored package due to wrong CRC. Incoming: {0:X} Local: {1:X}", (uint)num4, num5));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
this.bytesIn += 12L;
|
|
}
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
TrafficStats trafficStatsIncoming = base.TrafficStatsIncoming;
|
|
int totalPacketCount = trafficStatsIncoming.TotalPacketCount;
|
|
trafficStatsIncoming.TotalPacketCount = totalPacketCount + 1;
|
|
base.TrafficStatsIncoming.TotalCommandsInPackets += (int)b2;
|
|
}
|
|
bool flag9 = (int)b2 > this.commandBufferSize || b2 <= 0;
|
|
if (flag9)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.ERROR, string.Concat(new object[] { "too many/few incoming commands in package: ", b2, " > ", this.commandBufferSize }));
|
|
}
|
|
bool flag10 = num3 != this.challenge;
|
|
if (flag10)
|
|
{
|
|
this.packetLossByChallenge++;
|
|
bool flag11 = this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnected && base.debugOut >= DebugLevel.ALL;
|
|
if (flag11)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.ALL, string.Concat(new object[] { "Info: Ignoring received package due to wrong challenge. Challenge in-package!=local:", num3, "!=", this.challenge, " Commands in it: ", b2 }));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.timeInt = SupportClass.GetTickCount() - this.timeBase;
|
|
for (int i = 0; i < (int)b2; i++)
|
|
{
|
|
NCommand readCommand = new NCommand(this, inBuff, ref num);
|
|
bool flag12 = readCommand.commandType != 1;
|
|
if (flag12)
|
|
{
|
|
base.EnqueueActionForDispatch(delegate
|
|
{
|
|
this.ExecuteCommand(readCommand);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
this.ExecuteCommand(readCommand);
|
|
}
|
|
bool flag13 = (readCommand.commandFlags & 1) > 0;
|
|
if (flag13)
|
|
{
|
|
bool flag14 = this.InReliableLog != null;
|
|
if (flag14)
|
|
{
|
|
this.InReliableLog.Enqueue(new CmdLogReceivedReliable(readCommand, this.timeInt, this.roundTripTime, this.roundTripTimeVariance, this.timeInt - this.timeLastSendOutgoing, this.timeInt - this.timeLastSendAck));
|
|
base.CommandLogResize();
|
|
}
|
|
this.QueueOutgoingAcknowledgement(readCommand, this.serverSentTime);
|
|
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled2)
|
|
{
|
|
base.TrafficStatsIncoming.TimestampOfLastReliableCommand = SupportClass.GetTickCount();
|
|
base.TrafficStatsOutgoing.CountControlCommand(20);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
bool flag15 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag15)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.ERROR, string.Format("Exception while reading commands from incoming data: {0}", ex));
|
|
}
|
|
SupportClass.WriteStackTrace(ex);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600016A RID: 362 RVA: 0x0000CEA8 File Offset: 0x0000B0A8
|
|
internal bool ExecuteCommand(NCommand command)
|
|
{
|
|
bool flag = true;
|
|
switch (command.commandType)
|
|
{
|
|
case 1:
|
|
{
|
|
bool trafficStatsEnabled = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled)
|
|
{
|
|
base.TrafficStatsIncoming.TimestampOfLastAck = SupportClass.GetTickCount();
|
|
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
|
}
|
|
this.timeLastAckReceive = this.timeInt;
|
|
this.lastRoundTripTime = this.timeInt - command.ackReceivedSentTime;
|
|
NCommand ncommand = this.RemoveSentReliableCommand(command.ackReceivedReliableSequenceNumber, (int)command.commandChannelID);
|
|
bool flag2 = this.CommandLog != null;
|
|
if (flag2)
|
|
{
|
|
this.CommandLog.Enqueue(new CmdLogReceivedAck(command, this.timeInt, this.roundTripTime, this.roundTripTimeVariance));
|
|
base.CommandLogResize();
|
|
}
|
|
bool flag3 = ncommand != null;
|
|
if (flag3)
|
|
{
|
|
bool flag4 = ncommand.commandType == 12;
|
|
if (flag4)
|
|
{
|
|
bool flag5 = this.lastRoundTripTime <= this.roundTripTime;
|
|
if (flag5)
|
|
{
|
|
this.serverTimeOffset = this.serverSentTime + (this.lastRoundTripTime >> 1) - SupportClass.GetTickCount();
|
|
this.serverTimeOffsetIsAvailable = true;
|
|
}
|
|
else
|
|
{
|
|
this.FetchServerTimestamp();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base.UpdateRoundTripTimeAndVariance(this.lastRoundTripTime);
|
|
bool flag6 = ncommand.commandType == 4 && this.peerConnectionState == PeerBase.ConnectionStateValue.Disconnecting;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag7)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.INFO, "Received disconnect ACK by server");
|
|
}
|
|
base.EnqueueActionForDispatch(delegate
|
|
{
|
|
this.rt.Disconnect();
|
|
});
|
|
}
|
|
else
|
|
{
|
|
bool flag8 = ncommand.commandType == 2;
|
|
if (flag8)
|
|
{
|
|
this.roundTripTime = this.lastRoundTripTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
case 5:
|
|
{
|
|
bool trafficStatsEnabled2 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled2)
|
|
{
|
|
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
bool trafficStatsEnabled3 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled3)
|
|
{
|
|
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
|
}
|
|
bool flag9 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connecting;
|
|
if (flag9)
|
|
{
|
|
byte[] array = base.PrepareConnectData(base.ServerAddress, this.AppId, this.CustomInitData);
|
|
this.CreateAndEnqueueCommand(6, array, 0);
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Connected;
|
|
}
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
bool trafficStatsEnabled4 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled4)
|
|
{
|
|
base.TrafficStatsIncoming.CountControlCommand(command.Size);
|
|
}
|
|
StatusCode statusCode = StatusCode.DisconnectByServer;
|
|
bool flag10 = command.reservedByte == 1;
|
|
if (flag10)
|
|
{
|
|
statusCode = StatusCode.DisconnectByServerLogic;
|
|
}
|
|
else
|
|
{
|
|
bool flag11 = command.reservedByte == 3;
|
|
if (flag11)
|
|
{
|
|
statusCode = StatusCode.DisconnectByServerUserLimit;
|
|
}
|
|
}
|
|
bool flag12 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag12)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
|
{
|
|
"Server ",
|
|
base.ServerAddress,
|
|
" sent disconnect. PeerId: ",
|
|
(ushort)this.peerID,
|
|
" RTT/Variance:",
|
|
this.roundTripTime,
|
|
"/",
|
|
this.roundTripTimeVariance,
|
|
" reason byte: ",
|
|
command.reservedByte
|
|
}));
|
|
}
|
|
PeerBase.ConnectionStateValue peerConnectionState = this.peerConnectionState;
|
|
this.peerConnectionState = PeerBase.ConnectionStateValue.Disconnecting;
|
|
base.Listener.OnStatusChanged(statusCode);
|
|
this.peerConnectionState = peerConnectionState;
|
|
this.Disconnect();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
bool trafficStatsEnabled5 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled5)
|
|
{
|
|
base.TrafficStatsIncoming.CountReliableOpCommand(command.Size);
|
|
}
|
|
bool flag13 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
|
if (flag13)
|
|
{
|
|
flag = this.QueueIncomingCommand(command);
|
|
}
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
bool trafficStatsEnabled6 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled6)
|
|
{
|
|
base.TrafficStatsIncoming.CountUnreliableOpCommand(command.Size);
|
|
}
|
|
bool flag14 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
|
if (flag14)
|
|
{
|
|
flag = this.QueueIncomingCommand(command);
|
|
}
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
bool trafficStatsEnabled7 = base.TrafficStatsEnabled;
|
|
if (trafficStatsEnabled7)
|
|
{
|
|
base.TrafficStatsIncoming.CountFragmentOpCommand(command.Size);
|
|
}
|
|
bool flag15 = this.peerConnectionState == PeerBase.ConnectionStateValue.Connected;
|
|
if (flag15)
|
|
{
|
|
bool flag16 = command.fragmentNumber > command.fragmentCount || command.fragmentOffset >= command.totalLength || command.fragmentOffset + command.Payload.Length > command.totalLength;
|
|
if (flag16)
|
|
{
|
|
bool flag17 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag17)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, "Received fragment has bad size: " + command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flag = this.QueueIncomingCommand(command);
|
|
bool flag18 = flag;
|
|
if (flag18)
|
|
{
|
|
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
|
bool flag19 = command.reliableSequenceNumber == command.startSequenceNumber;
|
|
if (flag19)
|
|
{
|
|
command.fragmentsRemaining--;
|
|
int num = command.startSequenceNumber + 1;
|
|
while (command.fragmentsRemaining > 0 && num < command.startSequenceNumber + command.fragmentCount)
|
|
{
|
|
bool flag20 = channel.ContainsReliableSequenceNumber(num++);
|
|
if (flag20)
|
|
{
|
|
command.fragmentsRemaining--;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag21 = channel.ContainsReliableSequenceNumber(command.startSequenceNumber);
|
|
if (flag21)
|
|
{
|
|
NCommand ncommand2 = channel.FetchReliableSequenceNumber(command.startSequenceNumber);
|
|
ncommand2.fragmentsRemaining--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600016B RID: 363 RVA: 0x0000D41C File Offset: 0x0000B61C
|
|
internal bool QueueIncomingCommand(NCommand command)
|
|
{
|
|
EnetChannel channel = this.GetChannel(command.commandChannelID);
|
|
bool flag = channel == null;
|
|
bool flag3;
|
|
if (flag)
|
|
{
|
|
bool flag2 = base.debugOut >= DebugLevel.ERROR;
|
|
if (flag2)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ERROR, "Received command for non-existing channel: " + command.commandChannelID);
|
|
}
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = base.debugOut >= DebugLevel.ALL;
|
|
if (flag4)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.ALL, string.Concat(new object[] { "queueIncomingCommand() ", command, " channel seq# r/u: ", channel.incomingReliableSequenceNumber, "/", channel.incomingUnreliableSequenceNumber }));
|
|
}
|
|
bool flag5 = command.commandFlags == 1;
|
|
if (flag5)
|
|
{
|
|
bool flag6 = command.reliableSequenceNumber <= channel.incomingReliableSequenceNumber;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag7)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[] { "incoming command ", command, " is old (not saving it). Dispatched incomingReliableSequenceNumber: ", channel.incomingReliableSequenceNumber }));
|
|
}
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag8 = channel.ContainsReliableSequenceNumber(command.reliableSequenceNumber);
|
|
if (flag8)
|
|
{
|
|
bool flag9 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag9)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
|
{
|
|
"Info: command was received before! Old/New: ",
|
|
channel.FetchReliableSequenceNumber(command.reliableSequenceNumber),
|
|
"/",
|
|
command,
|
|
" inReliableSeq#: ",
|
|
channel.incomingReliableSequenceNumber
|
|
}));
|
|
}
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
channel.incomingReliableCommandsList.Add(command.reliableSequenceNumber, command);
|
|
flag3 = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag10 = command.commandFlags == 0;
|
|
if (flag10)
|
|
{
|
|
bool flag11 = command.reliableSequenceNumber < channel.incomingReliableSequenceNumber;
|
|
if (flag11)
|
|
{
|
|
bool flag12 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag12)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, "incoming reliable-seq# < Dispatched-rel-seq#. not saved.");
|
|
}
|
|
flag3 = true;
|
|
}
|
|
else
|
|
{
|
|
bool flag13 = command.unreliableSequenceNumber <= channel.incomingUnreliableSequenceNumber;
|
|
if (flag13)
|
|
{
|
|
bool flag14 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag14)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, "incoming unreliable-seq# < Dispatched-unrel-seq#. not saved.");
|
|
}
|
|
flag3 = true;
|
|
}
|
|
else
|
|
{
|
|
bool flag15 = channel.ContainsUnreliableSequenceNumber(command.unreliableSequenceNumber);
|
|
if (flag15)
|
|
{
|
|
bool flag16 = base.debugOut >= DebugLevel.INFO;
|
|
if (flag16)
|
|
{
|
|
base.Listener.DebugReturn(DebugLevel.INFO, string.Concat(new object[]
|
|
{
|
|
"command was received before! Old/New: ",
|
|
channel.incomingUnreliableCommandsList[command.unreliableSequenceNumber],
|
|
"/",
|
|
command
|
|
}));
|
|
}
|
|
flag3 = false;
|
|
}
|
|
else
|
|
{
|
|
channel.incomingUnreliableCommandsList.Add(command.unreliableSequenceNumber, command);
|
|
flag3 = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flag3 = false;
|
|
}
|
|
}
|
|
}
|
|
return flag3;
|
|
}
|
|
|
|
// Token: 0x0600016C RID: 364 RVA: 0x0000D71C File Offset: 0x0000B91C
|
|
internal NCommand RemoveSentReliableCommand(int ackReceivedReliableSequenceNumber, int ackReceivedChannel)
|
|
{
|
|
NCommand ncommand = null;
|
|
List<NCommand> list = this.sentReliableCommands;
|
|
lock (list)
|
|
{
|
|
foreach (NCommand ncommand2 in this.sentReliableCommands)
|
|
{
|
|
bool flag = ncommand2 != null && ncommand2.reliableSequenceNumber == ackReceivedReliableSequenceNumber && (int)ncommand2.commandChannelID == ackReceivedChannel;
|
|
if (flag)
|
|
{
|
|
ncommand = ncommand2;
|
|
break;
|
|
}
|
|
}
|
|
bool flag2 = ncommand != null;
|
|
if (flag2)
|
|
{
|
|
this.sentReliableCommands.Remove(ncommand);
|
|
bool flag3 = this.sentReliableCommands.Count > 0;
|
|
if (flag3)
|
|
{
|
|
this.timeoutInt = this.timeInt + 25;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = base.debugOut >= DebugLevel.ALL && this.peerConnectionState != PeerBase.ConnectionStateValue.Connected && this.peerConnectionState != PeerBase.ConnectionStateValue.Disconnecting;
|
|
if (flag4)
|
|
{
|
|
base.EnqueueDebugReturn(DebugLevel.ALL, string.Format("No sent command for ACK (Ch: {0} Sq#: {1}). PeerState: {2}.", ackReceivedReliableSequenceNumber, ackReceivedChannel, this.peerConnectionState));
|
|
}
|
|
}
|
|
}
|
|
return ncommand;
|
|
}
|
|
|
|
// Token: 0x0600016D RID: 365 RVA: 0x0000D854 File Offset: 0x0000BA54
|
|
internal string CommandListToString(NCommand[] list)
|
|
{
|
|
bool flag = base.debugOut < DebugLevel.ALL;
|
|
string text;
|
|
if (flag)
|
|
{
|
|
text = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < list.Length; i++)
|
|
{
|
|
stringBuilder.Append(i + "=");
|
|
stringBuilder.Append(list[i]);
|
|
stringBuilder.Append(" # ");
|
|
}
|
|
text = stringBuilder.ToString();
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x040000A9 RID: 169
|
|
private const int CRC_LENGTH = 4;
|
|
|
|
// Token: 0x040000AA RID: 170
|
|
private static readonly int HMAC_SIZE = 32;
|
|
|
|
// Token: 0x040000AB RID: 171
|
|
private static readonly int BLOCK_SIZE = 16;
|
|
|
|
// Token: 0x040000AC RID: 172
|
|
private static readonly int IV_SIZE = 16;
|
|
|
|
// Token: 0x040000AD RID: 173
|
|
private const int EncryptedDataGramHeaderSize = 7;
|
|
|
|
// Token: 0x040000AE RID: 174
|
|
private const int EncryptedHeaderSize = 5;
|
|
|
|
// Token: 0x040000AF RID: 175
|
|
private List<NCommand> sentReliableCommands = new List<NCommand>();
|
|
|
|
// Token: 0x040000B0 RID: 176
|
|
private StreamBuffer outgoingAcknowledgementsPool;
|
|
|
|
// Token: 0x040000B1 RID: 177
|
|
internal readonly int windowSize = 128;
|
|
|
|
// Token: 0x040000B2 RID: 178
|
|
private byte udpCommandCount;
|
|
|
|
// Token: 0x040000B3 RID: 179
|
|
private byte[] udpBuffer;
|
|
|
|
// Token: 0x040000B4 RID: 180
|
|
private int udpBufferIndex;
|
|
|
|
// Token: 0x040000B5 RID: 181
|
|
private int udpBufferLength;
|
|
|
|
// Token: 0x040000B6 RID: 182
|
|
private byte[] bufferForEncryption;
|
|
|
|
// Token: 0x040000B7 RID: 183
|
|
internal int challenge;
|
|
|
|
// Token: 0x040000B8 RID: 184
|
|
internal int reliableCommandsRepeated;
|
|
|
|
// Token: 0x040000B9 RID: 185
|
|
internal int reliableCommandsSent;
|
|
|
|
// Token: 0x040000BA RID: 186
|
|
internal int serverSentTime;
|
|
|
|
// Token: 0x040000BB RID: 187
|
|
internal static readonly byte[] udpHeader0xF3 = new byte[] { 243, 2 };
|
|
|
|
// Token: 0x040000BC RID: 188
|
|
internal static readonly byte[] messageHeader = EnetPeer.udpHeader0xF3;
|
|
|
|
// Token: 0x040000BD RID: 189
|
|
protected bool datagramEncryptedConnection;
|
|
|
|
// Token: 0x040000BE RID: 190
|
|
private EnetChannel[] channelArray = new EnetChannel[0];
|
|
|
|
// Token: 0x040000BF RID: 191
|
|
private const byte ControlChannelNumber = 255;
|
|
|
|
// Token: 0x040000C0 RID: 192
|
|
protected internal const short PeerIdForConnect = -1;
|
|
|
|
// Token: 0x040000C1 RID: 193
|
|
protected internal const short PeerIdForConnectTrace = -2;
|
|
|
|
// Token: 0x040000C2 RID: 194
|
|
private Queue<int> commandsToRemove = new Queue<int>();
|
|
|
|
// Token: 0x040000C3 RID: 195
|
|
private Queue<NCommand> commandsToResend = new Queue<NCommand>();
|
|
}
|
|
}
|