niko
472 lines
13 KiB
C#
472 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace UnityEngine.Networking
|
|
{
|
|
// Token: 0x02000002 RID: 2
|
|
internal class ChannelBuffer : IDisposable
|
|
{
|
|
// Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
|
|
public ChannelBuffer(NetworkConnection conn, int bufferSize, byte cid, bool isReliable, bool isSequenced)
|
|
{
|
|
this.m_Connection = conn;
|
|
this.m_MaxPacketSize = bufferSize - 100;
|
|
this.m_CurrentPacket = new ChannelPacket(this.m_MaxPacketSize, isReliable);
|
|
this.m_ChannelId = cid;
|
|
this.m_MaxPendingPacketCount = 16;
|
|
this.m_IsReliable = isReliable;
|
|
this.m_AllowFragmentation = isReliable && isSequenced;
|
|
if (isReliable)
|
|
{
|
|
this.m_PendingPackets = new Queue<ChannelPacket>();
|
|
if (ChannelBuffer.s_FreePackets == null)
|
|
{
|
|
ChannelBuffer.s_FreePackets = new List<ChannelPacket>();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000001 RID: 1
|
|
// (get) Token: 0x06000002 RID: 2 RVA: 0x00002104 File Offset: 0x00000304
|
|
// (set) Token: 0x06000003 RID: 3 RVA: 0x0000211E File Offset: 0x0000031E
|
|
public int numMsgsOut { get; private set; }
|
|
|
|
// Token: 0x17000002 RID: 2
|
|
// (get) Token: 0x06000004 RID: 4 RVA: 0x00002128 File Offset: 0x00000328
|
|
// (set) Token: 0x06000005 RID: 5 RVA: 0x00002142 File Offset: 0x00000342
|
|
public int numBufferedMsgsOut { get; private set; }
|
|
|
|
// Token: 0x17000003 RID: 3
|
|
// (get) Token: 0x06000006 RID: 6 RVA: 0x0000214C File Offset: 0x0000034C
|
|
// (set) Token: 0x06000007 RID: 7 RVA: 0x00002166 File Offset: 0x00000366
|
|
public int numBytesOut { get; private set; }
|
|
|
|
// Token: 0x17000004 RID: 4
|
|
// (get) Token: 0x06000008 RID: 8 RVA: 0x00002170 File Offset: 0x00000370
|
|
// (set) Token: 0x06000009 RID: 9 RVA: 0x0000218A File Offset: 0x0000038A
|
|
public int numMsgsIn { get; private set; }
|
|
|
|
// Token: 0x17000005 RID: 5
|
|
// (get) Token: 0x0600000A RID: 10 RVA: 0x00002194 File Offset: 0x00000394
|
|
// (set) Token: 0x0600000B RID: 11 RVA: 0x000021AE File Offset: 0x000003AE
|
|
public int numBytesIn { get; private set; }
|
|
|
|
// Token: 0x17000006 RID: 6
|
|
// (get) Token: 0x0600000C RID: 12 RVA: 0x000021B8 File Offset: 0x000003B8
|
|
// (set) Token: 0x0600000D RID: 13 RVA: 0x000021D2 File Offset: 0x000003D2
|
|
public int numBufferedPerSecond { get; private set; }
|
|
|
|
// Token: 0x17000007 RID: 7
|
|
// (get) Token: 0x0600000E RID: 14 RVA: 0x000021DC File Offset: 0x000003DC
|
|
// (set) Token: 0x0600000F RID: 15 RVA: 0x000021F6 File Offset: 0x000003F6
|
|
public int lastBufferedPerSecond { get; private set; }
|
|
|
|
// Token: 0x06000010 RID: 16 RVA: 0x000021FF File Offset: 0x000003FF
|
|
public void Dispose()
|
|
{
|
|
this.Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
// Token: 0x06000011 RID: 17 RVA: 0x00002210 File Offset: 0x00000410
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!this.m_Disposed)
|
|
{
|
|
if (disposing)
|
|
{
|
|
if (this.m_PendingPackets != null)
|
|
{
|
|
while (this.m_PendingPackets.Count > 0)
|
|
{
|
|
ChannelBuffer.pendingPacketCount--;
|
|
ChannelPacket channelPacket = this.m_PendingPackets.Dequeue();
|
|
if (ChannelBuffer.s_FreePackets.Count < 512)
|
|
{
|
|
ChannelBuffer.s_FreePackets.Add(channelPacket);
|
|
}
|
|
}
|
|
this.m_PendingPackets.Clear();
|
|
}
|
|
}
|
|
}
|
|
this.m_Disposed = true;
|
|
}
|
|
|
|
// Token: 0x06000012 RID: 18 RVA: 0x000022A4 File Offset: 0x000004A4
|
|
public bool SetOption(ChannelOption option, int value)
|
|
{
|
|
bool flag;
|
|
if (option != ChannelOption.MaxPendingBuffers)
|
|
{
|
|
if (option != ChannelOption.AllowFragmentation)
|
|
{
|
|
if (option != ChannelOption.MaxPacketSize)
|
|
{
|
|
flag = false;
|
|
}
|
|
else if (!this.m_CurrentPacket.IsEmpty() || this.m_PendingPackets.Count > 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Cannot set MaxPacketSize after sending data.");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (value <= 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Cannot set MaxPacketSize less than one.");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (value > this.m_MaxPacketSize)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("Cannot set MaxPacketSize to greater than the existing maximum (" + this.m_MaxPacketSize + ").");
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_CurrentPacket = new ChannelPacket(value, this.m_IsReliable);
|
|
this.m_MaxPacketSize = value;
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.m_AllowFragmentation = value != 0;
|
|
flag = true;
|
|
}
|
|
}
|
|
else if (!this.m_IsReliable)
|
|
{
|
|
flag = false;
|
|
}
|
|
else if (value < 0 || value >= 512)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError(string.Concat(new object[] { "Invalid MaxPendingBuffers for channel ", this.m_ChannelId, ". Must be greater than zero and less than ", 512 }));
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_MaxPendingPacketCount = value;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000013 RID: 19 RVA: 0x00002430 File Offset: 0x00000630
|
|
public void CheckInternalBuffer()
|
|
{
|
|
if (Time.realtimeSinceStartup - this.m_LastFlushTime > this.maxDelay && !this.m_CurrentPacket.IsEmpty())
|
|
{
|
|
this.SendInternalBuffer();
|
|
this.m_LastFlushTime = Time.realtimeSinceStartup;
|
|
}
|
|
if (Time.realtimeSinceStartup - this.m_LastBufferedMessageCountTimer > 1f)
|
|
{
|
|
this.lastBufferedPerSecond = this.numBufferedPerSecond;
|
|
this.numBufferedPerSecond = 0;
|
|
this.m_LastBufferedMessageCountTimer = Time.realtimeSinceStartup;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000014 RID: 20 RVA: 0x000024B0 File Offset: 0x000006B0
|
|
public bool SendWriter(NetworkWriter writer)
|
|
{
|
|
return this.SendBytes(writer.AsArraySegment().Array, writer.AsArraySegment().Count);
|
|
}
|
|
|
|
// Token: 0x06000015 RID: 21 RVA: 0x000024E8 File Offset: 0x000006E8
|
|
public bool Send(short msgType, MessageBase msg)
|
|
{
|
|
ChannelBuffer.s_SendWriter.StartMessage(msgType);
|
|
msg.Serialize(ChannelBuffer.s_SendWriter);
|
|
ChannelBuffer.s_SendWriter.FinishMessage();
|
|
this.numMsgsOut++;
|
|
return this.SendWriter(ChannelBuffer.s_SendWriter);
|
|
}
|
|
|
|
// Token: 0x06000016 RID: 22 RVA: 0x00002538 File Offset: 0x00000738
|
|
internal bool HandleFragment(NetworkReader reader)
|
|
{
|
|
bool flag;
|
|
if (reader.ReadByte() == 0)
|
|
{
|
|
if (!this.readingFragment)
|
|
{
|
|
this.fragmentBuffer.SeekZero();
|
|
this.readingFragment = true;
|
|
}
|
|
byte[] array = reader.ReadBytesAndSize();
|
|
this.fragmentBuffer.WriteBytes(array, (ushort)array.Length);
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.readingFragment = false;
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000017 RID: 23 RVA: 0x000025A4 File Offset: 0x000007A4
|
|
internal bool SendFragmentBytes(byte[] bytes, int bytesToSend)
|
|
{
|
|
int num = 0;
|
|
while (bytesToSend > 0)
|
|
{
|
|
int num2 = Math.Min(bytesToSend, this.m_MaxPacketSize - 32);
|
|
byte[] array = new byte[num2];
|
|
Array.Copy(bytes, num, array, 0, num2);
|
|
ChannelBuffer.s_FragmentWriter.StartMessage(17);
|
|
ChannelBuffer.s_FragmentWriter.Write(0);
|
|
ChannelBuffer.s_FragmentWriter.WriteBytesFull(array);
|
|
ChannelBuffer.s_FragmentWriter.FinishMessage();
|
|
this.SendWriter(ChannelBuffer.s_FragmentWriter);
|
|
num += num2;
|
|
bytesToSend -= num2;
|
|
}
|
|
ChannelBuffer.s_FragmentWriter.StartMessage(17);
|
|
ChannelBuffer.s_FragmentWriter.Write(1);
|
|
ChannelBuffer.s_FragmentWriter.FinishMessage();
|
|
this.SendWriter(ChannelBuffer.s_FragmentWriter);
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06000018 RID: 24 RVA: 0x0000265C File Offset: 0x0000085C
|
|
internal bool SendBytes(byte[] bytes, int bytesToSend)
|
|
{
|
|
bool flag;
|
|
if (bytesToSend >= 65535)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("ChannelBuffer:SendBytes cannot send packet larger than " + ushort.MaxValue + " bytes");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (bytesToSend <= 0)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("ChannelBuffer:SendBytes cannot send zero bytes");
|
|
}
|
|
flag = false;
|
|
}
|
|
else if (bytesToSend > this.m_MaxPacketSize)
|
|
{
|
|
if (this.m_AllowFragmentation)
|
|
{
|
|
flag = this.SendFragmentBytes(bytes, bytesToSend);
|
|
}
|
|
else
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError(string.Concat(new object[] { "Failed to send big message of ", bytesToSend, " bytes. The maximum is ", this.m_MaxPacketSize, " bytes on channel:", this.m_ChannelId }));
|
|
}
|
|
flag = false;
|
|
}
|
|
}
|
|
else if (!this.m_CurrentPacket.HasSpace(bytesToSend))
|
|
{
|
|
if (this.m_IsReliable)
|
|
{
|
|
if (this.m_PendingPackets.Count == 0)
|
|
{
|
|
if (!this.m_CurrentPacket.SendToTransport(this.m_Connection, (int)this.m_ChannelId))
|
|
{
|
|
this.QueuePacket();
|
|
}
|
|
this.m_CurrentPacket.Write(bytes, bytesToSend);
|
|
flag = true;
|
|
}
|
|
else if (this.m_PendingPackets.Count >= this.m_MaxPendingPacketCount)
|
|
{
|
|
if (!this.m_IsBroken)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("ChannelBuffer buffer limit of " + this.m_PendingPackets.Count + " packets reached.");
|
|
}
|
|
}
|
|
this.m_IsBroken = true;
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.QueuePacket();
|
|
this.m_CurrentPacket.Write(bytes, bytesToSend);
|
|
flag = true;
|
|
}
|
|
}
|
|
else if (!this.m_CurrentPacket.SendToTransport(this.m_Connection, (int)this.m_ChannelId))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.Log("ChannelBuffer SendBytes no space on unreliable channel " + this.m_ChannelId);
|
|
}
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
this.m_CurrentPacket.Write(bytes, bytesToSend);
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.m_CurrentPacket.Write(bytes, bytesToSend);
|
|
flag = this.maxDelay != 0f || this.SendInternalBuffer();
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000019 RID: 25 RVA: 0x000028C7 File Offset: 0x00000AC7
|
|
private void QueuePacket()
|
|
{
|
|
ChannelBuffer.pendingPacketCount++;
|
|
this.m_PendingPackets.Enqueue(this.m_CurrentPacket);
|
|
this.m_CurrentPacket = this.AllocPacket();
|
|
}
|
|
|
|
// Token: 0x0600001A RID: 26 RVA: 0x000028F4 File Offset: 0x00000AF4
|
|
private ChannelPacket AllocPacket()
|
|
{
|
|
ChannelPacket channelPacket;
|
|
if (ChannelBuffer.s_FreePackets.Count == 0)
|
|
{
|
|
channelPacket = new ChannelPacket(this.m_MaxPacketSize, this.m_IsReliable);
|
|
}
|
|
else
|
|
{
|
|
ChannelPacket channelPacket2 = ChannelBuffer.s_FreePackets[ChannelBuffer.s_FreePackets.Count - 1];
|
|
ChannelBuffer.s_FreePackets.RemoveAt(ChannelBuffer.s_FreePackets.Count - 1);
|
|
channelPacket2.Reset();
|
|
channelPacket = channelPacket2;
|
|
}
|
|
return channelPacket;
|
|
}
|
|
|
|
// Token: 0x0600001B RID: 27 RVA: 0x00002965 File Offset: 0x00000B65
|
|
private static void FreePacket(ChannelPacket packet)
|
|
{
|
|
if (ChannelBuffer.s_FreePackets.Count < 512)
|
|
{
|
|
ChannelBuffer.s_FreePackets.Add(packet);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001C RID: 28 RVA: 0x00002990 File Offset: 0x00000B90
|
|
public bool SendInternalBuffer()
|
|
{
|
|
bool flag;
|
|
if (this.m_IsReliable && this.m_PendingPackets.Count > 0)
|
|
{
|
|
while (this.m_PendingPackets.Count > 0)
|
|
{
|
|
ChannelPacket channelPacket = this.m_PendingPackets.Dequeue();
|
|
if (!channelPacket.SendToTransport(this.m_Connection, (int)this.m_ChannelId))
|
|
{
|
|
this.m_PendingPackets.Enqueue(channelPacket);
|
|
break;
|
|
}
|
|
ChannelBuffer.pendingPacketCount--;
|
|
ChannelBuffer.FreePacket(channelPacket);
|
|
if (this.m_IsBroken && this.m_PendingPackets.Count < this.m_MaxPendingPacketCount / 2)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("ChannelBuffer recovered from overflow but data was lost.");
|
|
}
|
|
this.m_IsBroken = false;
|
|
}
|
|
}
|
|
flag = true;
|
|
}
|
|
else
|
|
{
|
|
flag = this.m_CurrentPacket.SendToTransport(this.m_Connection, (int)this.m_ChannelId);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x04000001 RID: 1
|
|
private NetworkConnection m_Connection;
|
|
|
|
// Token: 0x04000002 RID: 2
|
|
private ChannelPacket m_CurrentPacket;
|
|
|
|
// Token: 0x04000003 RID: 3
|
|
private float m_LastFlushTime;
|
|
|
|
// Token: 0x04000004 RID: 4
|
|
private byte m_ChannelId;
|
|
|
|
// Token: 0x04000005 RID: 5
|
|
private int m_MaxPacketSize;
|
|
|
|
// Token: 0x04000006 RID: 6
|
|
private bool m_IsReliable;
|
|
|
|
// Token: 0x04000007 RID: 7
|
|
private bool m_AllowFragmentation;
|
|
|
|
// Token: 0x04000008 RID: 8
|
|
private bool m_IsBroken;
|
|
|
|
// Token: 0x04000009 RID: 9
|
|
private int m_MaxPendingPacketCount;
|
|
|
|
// Token: 0x0400000A RID: 10
|
|
private const int k_MaxFreePacketCount = 512;
|
|
|
|
// Token: 0x0400000B RID: 11
|
|
public const int MaxPendingPacketCount = 16;
|
|
|
|
// Token: 0x0400000C RID: 12
|
|
public const int MaxBufferedPackets = 512;
|
|
|
|
// Token: 0x0400000D RID: 13
|
|
private Queue<ChannelPacket> m_PendingPackets;
|
|
|
|
// Token: 0x0400000E RID: 14
|
|
private static List<ChannelPacket> s_FreePackets;
|
|
|
|
// Token: 0x0400000F RID: 15
|
|
internal static int pendingPacketCount;
|
|
|
|
// Token: 0x04000010 RID: 16
|
|
public float maxDelay = 0.01f;
|
|
|
|
// Token: 0x04000011 RID: 17
|
|
private float m_LastBufferedMessageCountTimer = Time.realtimeSinceStartup;
|
|
|
|
// Token: 0x04000019 RID: 25
|
|
private static NetworkWriter s_SendWriter = new NetworkWriter();
|
|
|
|
// Token: 0x0400001A RID: 26
|
|
private static NetworkWriter s_FragmentWriter = new NetworkWriter();
|
|
|
|
// Token: 0x0400001B RID: 27
|
|
private const int k_PacketHeaderReserveSize = 100;
|
|
|
|
// Token: 0x0400001C RID: 28
|
|
private bool m_Disposed;
|
|
|
|
// Token: 0x0400001D RID: 29
|
|
internal NetBuffer fragmentBuffer = new NetBuffer();
|
|
|
|
// Token: 0x0400001E RID: 30
|
|
private bool readingFragment = false;
|
|
}
|
|
}
|