public void Execute(HttpRequest httpRequest)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Data
Entity entity = new Entity(null);
entity.EntityShutdown += Listener;
EntityIdleComponent idle = new EntityIdleComponent();
entity.Add(idle);
SessionComponent session = new SessionComponent()
{
Key = Key.Parse(httpRequest.Data)
};
entity.Add(session);
SessionMap.Add(session.Id, entity);
Server.Sessions = SessionMap.Count;
// TODO: Use Diffie–Hellman
//
// Response
HttpResponse httpResponse = new HttpResponse(session.Id)
{
Data = SecurityUtil.Token
};
channel.Send(httpResponse);
#if DEBUG
LogComponent log = new LogComponent(Log.Controller);
entity.Add(log);
Log.Add(httpRequest, httpResponse);
#endif
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest, SessionComponent session)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonInfoRequestMessage jsonRequestMessage = JsonInfoRequestMessage.Parse(jsonRequest.Message);
// Data
HttpCode code = HttpCode.Ok;
Entity entity = session.Owner;
TunnelComponent tunnel = entity.Get <TunnelComponent>();
if (tunnel != null)
{
PingRequestCommand command = new PingRequestCommand(entity, tunnel.Connection);
code = command.Execute();
if (code == HttpCode.Ok)
{
entity.Update();
}
}
// Response
JsonInfoResponseMessage jsonResponseMessage = new JsonInfoResponseMessage()
{
Entities = Server.Entities, Sessions = Server.Sessions, Clients = Server.Clients, Groups = Server.Groups
};
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse(code)
{
Data = session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
/// <summary>
/// Takes a Message and does something with it.
/// </summary>
/// <param name="peerId"></param>
/// <param name="channelId"></param>
/// <param name="data"></param>
private void OnMessage(ulong peerId, byte channelId, byte[] data)
{
NetworkChannel channel = (NetworkChannel)channelId;
//Debug.Log("Got Messege from: " + peerId + " on Channel: " + channel);
switch (channel)
{
case NetworkChannel.INPUT_DATA:
PlayerHandler.INSTANCE?.SetInputOnController(data);
break;
case NetworkChannel.LOADSCENE:
GameManager.LoadSceneData sceneToLoad = new GameManager.LoadSceneData(data);
GameManager.INSTANCE.LoadScene(sceneToLoad.scene);
break;
case NetworkChannel.CHARACTER_POSITION:
PlayerHandler.INSTANCE?.SetPositionOfCharacter(data);
break;
case NetworkChannel.CONTROLLER_SYNC:
PlayerHandler.PlayerHandlerData handlerData = new PlayerHandler.PlayerHandlerData(data);
PlayerHandler.INSTANCE?.SetAllPlayers(handlerData.orderSelected, handlerData.orderOfId);
break;
case NetworkChannel.SCORE_SYNC:
ScoreData scoreData = new ScoreData(data);
ScoreUpdater.INSTANCE?.UpdateScore(scoreData);
break;
case NetworkChannel.PORTRAITS_SYNC:
DisplayPlayers.INSTANCE.SetOrder(data);
break;
default:
Debug.Log(peerId + " : Sent messege was not reognized");
break;
}
}
public void ShouldReceiveOnChildWhenSent()
{
var childAddress = new NodeAddress("child");
var localAddress = new NodeAddress("local");
var data = NetworkChannel <string> .Serialize("Hello world");
var child = new Mock <INode>();
child.Setup(x => x.Address).Returns(childAddress);
var network = new Mock <INetwork>();
network.Setup(x => x.FindOrDefault(null)).Returns((INode)null);
network.Setup(x => x.FindOrCreate(childAddress)).Returns(child.Object);
network.Setup(x => x.FindOrDefault(childAddress)).Returns(child.Object);
var local = new Node(localAddress, network.Object);
local.Connect(childAddress);
local.Send(typeof(string).ToString(), data, null);
child.Verify(x => x.Send(typeof(string).ToString(), data, It.IsAny <NodeAddress>()));
}
public HttpCode Execute(string jsonId, string jsonData, JsonChunk jsonChunk)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonDownloadRequestMessage jsonRequestMessage = new JsonDownloadRequestMessage(jsonId)
{
Chunk = jsonChunk
};
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, jsonData);
HttpRequest httpRequest = new HttpRequest()
{
Data = Session.Encrypt(jsonRequest)
};
// Response
HttpResponse httpResponse;
lock (Socket)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
return(Code);
}
public void Execute(HttpRequest httpRequest, JsonPacket jsonRequest)
{
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonPingRequestMessage jsonRequestMessage = JsonPingRequestMessage.Parse(jsonRequest.Message);
// Response
JsonPingResponseMessage jsonResponseMessage = new JsonPingResponseMessage();
JsonPacket jsonResponse = new JsonPacket(jsonResponseMessage);
HttpResponse httpResponse = new HttpResponse()
{
Data = Session.Encrypt(jsonResponse)
};
channel.Send(httpResponse);
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
}
public void ReadStatus(NetIncomingMessage message)
{
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
NetworkChannel channel = (NetworkChannel)message.SequenceChannel;
if (message.SequenceChannel < 0 || message.SequenceChannel > 32)
{
channel = NetworkChannel.LOGIN;
}
NetworkConnection connection = GetConnection(this, message);
Debug.Log($"Network status changed {status.ToString()}");
if (status == NetConnectionStatus.Connected)
{
OnConnectionCreate(this, message.SenderConnection);
}
if (status == NetConnectionStatus.Disconnected)
{
OnDisconnect(this, connection, message);
}
connection?.GetNetworkHandler(channel).OnStatusChange(status);
}
internal static void Send(ulong clientId, byte messageType, NetworkChannel networkChannel, NetworkBuffer messageBuffer)
{
messageBuffer.PadBuffer();
if (NetworkManager.Singleton.IsServer && clientId == NetworkManager.Singleton.ServerClientId)
{
return;
}
using (var buffer = MessagePacker.WrapMessage(messageType, messageBuffer))
{
NetworkProfiler.StartEvent(TickType.Send, (uint)buffer.Length, networkChannel, NetworkConstants.MESSAGE_NAMES[messageType]);
NetworkManager.Singleton.NetworkConfig.NetworkTransport.Send(clientId, new ArraySegment <byte>(buffer.GetBuffer(), 0, (int)buffer.Length), networkChannel);
ProfilerStatManager.BytesSent.Record((int)buffer.Length);
PerformanceDataManager.Increment(ProfilerConstants.ByteSent, (int)buffer.Length);
#if !UNITY_2020_2_OR_NEWER
NetworkProfiler.EndEvent();
#endif
}
}
private void AppendChannel(ref ArraySegment <byte> data, NetworkChannel channel)
{
Assert.IsNotNull(data.Array);
var index = data.Offset + data.Count;
var size = index + 1;
var array = data.Array;
if (data.Array.Length < size)
{
if (size > m_MessageBuffer.Length)
{
ResizeMessageBuffer(size);
}
array = m_MessageBuffer;
}
array[index] = (byte)channel;
data = new ArraySegment <byte>(array, data.Offset, data.Count + 1);
}
public void ShouldNotReceiveOnChildWhenSentToNetworkFromChild()
{
var childAddress = new NodeAddress("child");
var localAddress = new NodeAddress("local");
var data = "Hello world";
var child = new Mock <INode>();
child.Setup(x => x.Address).Returns(childAddress);
var network = new Mock <INetwork>();
network.Setup(x => x.FindOrDefault(null)).Returns((INode)null);
network.Setup(x => x.FindOrCreate(childAddress)).Returns(child.Object);
network.Setup(x => x.FindOrDefault(childAddress)).Returns(child.Object);
var local = new Node(localAddress, network.Object);
local.Connect(childAddress);
local.SendToNetwork(network.Object, typeof(string).ToString(), NetworkChannel <string> .Serialize(data), childAddress);
child.Verify(x => x.Send(typeof(string).ToString(), It.IsAny <byte[]>(), It.IsAny <NodeAddress>()), Times.Never());
}
private QueuedBlockMsg ReadUncompressedMsg(NetworkChannel netChan)
{
byte[] networkReadWorkingBuf = this.m_networkReadWorkingBuf;
GranularLogDataMsg granularLogDataMsg = GranularLogDataMsg.ReadFromNet(netChan, networkReadWorkingBuf, 0);
byte[] array = null;
int num = 0;
if (granularLogDataMsg.LogDataLength > 0)
{
this.GetAppendSpace(granularLogDataMsg.LogDataLength);
array = this.m_currentBuffer.Buffer;
num = this.m_currentBuffer.AppendOffset;
netChan.Read(array, num, granularLogDataMsg.LogDataLength);
this.m_currentBuffer.AppendOffset = num + granularLogDataMsg.LogDataLength;
}
return(new QueuedBlockMsg(granularLogDataMsg.EmitContext, array, num, 0)
{
RequestAckCounter = granularLogDataMsg.RequestAckCounter,
IOBuffer = this.m_currentBuffer
});
}
public string Execute(string jsonData)
{
Clear();
// Connect
NetworkChannel channel = new NetworkChannel(Connection);
// Request
JsonSearchRequestMessage jsonRequestMessage = new JsonSearchRequestMessage();
JsonPacket jsonRequest = new JsonPacket(jsonRequestMessage, jsonData);
HttpRequest httpRequest = new HttpRequest()
{
Data = Session.Encrypt(jsonRequest)
};
// Response
HttpResponse httpResponse;
// NOTE: We need to lock this send/receive message pairs
lock (Socket)
{
channel.Send(httpRequest);
channel.Receive(out httpResponse);
}
Code = httpResponse.Code;
if (httpResponse.Ok)
{
JsonPacket jsonResponse = JsonPacket.Parse(Session.Decrypt(httpResponse.Data));
#if DEBUG
Log.Add(httpRequest, httpResponse, jsonRequest, jsonResponse);
#endif
// Data
return(jsonResponse.Data);
}
return(null);
}
private QueuedBlockMsg ReadInputMessage(NetworkChannel netChan)
{
this.m_timeoutPending = false;
byte[] networkReadWorkingBuf = this.m_networkReadWorkingBuf;
StopwatchStamp stamp = StopwatchStamp.GetStamp();
NetworkChannelMessageHeader msgHdr = NetworkChannelMessage.ReadHeaderFromNet(netChan, networkReadWorkingBuf, 0);
NetworkChannelMessage.MessageType messageType = msgHdr.MessageType;
QueuedBlockMsg queuedBlockMsg;
if (messageType != NetworkChannelMessage.MessageType.BlockModeCompressedData)
{
if (messageType == NetworkChannelMessage.MessageType.Ping)
{
PingMessage pingMessage = PingMessage.ReadFromNet(netChan, networkReadWorkingBuf, 0);
long systemPerformanceCounter = Win32StopWatch.GetSystemPerformanceCounter();
long arg = Win32StopWatch.ComputeElapsedTimeInUSec(systemPerformanceCounter, pingMessage.ReplyAckCounter) / 1000L;
this.Copier.TrackLastContactTime(msgHdr.MessageUtc);
PassiveBlockMode.Tracer.TraceDebug <string, long>((long)this.GetHashCode(), "ProcessReadCallback({0}) received a ping after {1}ms, so channel is healthy", this.DatabaseName, arg);
return(null);
}
if (messageType != NetworkChannelMessage.MessageType.GranularLogData)
{
throw new NetworkUnexpectedMessageException(netChan.PartnerNodeName, string.Format("Unknown Type {0}", msgHdr.MessageType));
}
queuedBlockMsg = this.ReadUncompressedMsg(netChan);
this.Copier.PerfmonCounters.CompressionEnabled = 0L;
}
else
{
queuedBlockMsg = this.ReadCompressedMsg(netChan, msgHdr);
this.Copier.PerfmonCounters.CompressionEnabled = 1L;
}
queuedBlockMsg.ReadDurationInTics = stamp.ElapsedTicks;
queuedBlockMsg.MessageUtc = msgHdr.MessageUtc;
this.Copier.PerfmonCounters.RecordLogCopierNetworkReadLatency(queuedBlockMsg.ReadDurationInTics);
return(queuedBlockMsg);
}
void Initialize()
{
Debug.Log("Starting GameLogicChat");
apg = new AudiencePlayersSys(this, recorder);
if (UseSingleMachineTestNetworking)
{
IRCChat = new NullNetwork();
IRCLogic = new NullNetwork();
}
else
{
LoadNetworkSettings();
IRCChat = this.GetComponent <TwitchIRCChat>();
IRCLogic = this.GetComponent <TwitchIRCLogic>();
}
IRCChat.SetOAuthFunc(() => settings.ChatOauth);
IRCChat.SetChannelNameFunc(() => settings.ChatChannelName);
IRCLogic.SetOAuthFunc(() => settings.LogicOauth);
IRCLogic.SetChannelNameFunc(() => settings.LogicChannelName);
}
private PassiveReadRequest StartRead()
{
NetworkChannel netChannel = this.m_netChannel;
PassiveReadRequest passiveReadRequest = new PassiveReadRequest(this, netChannel);
bool flag = false;
try
{
if (!this.Copier.TestHungPassiveBlockMode)
{
netChannel.StartRead(new NetworkChannelCallback(PassiveBlockMode.ReadCallback), passiveReadRequest);
flag = true;
}
}
finally
{
if (!flag)
{
PassiveBlockMode.Tracer.TraceError((long)this.GetHashCode(), "Failed to start async read");
}
}
return(passiveReadRequest);
}
public void TestChannelPackerErrorEncode()
{
var fromClient = new byte[] { };
using (var server = new TcpServer((data) =>
{
fromClient = Arr.Merge(fromClient, data);
}))
{
var socket = MakeEnv().Make <ISocketManager>().Make("tcp://127.0.0.1", "TestChannelPackerErrorEncode");
var channel = new NetworkChannel(socket, new PackerError(PackerError.ErrorType.Encode), "TestChannelPackerErrorEncode");
var wait = channel.Connect("127.0.0.1", 7777);
var count = 0;
while (!wait.IsDone && count++ < 3000)
{
Thread.Sleep(1);
}
try
{
var isThrow = false;
try
{
channel.Send(Encoding.Default.GetBytes("helloworld"));
}
catch (RuntimeException)
{
isThrow = true;
}
Assert.AreEqual(true, isThrow);
}
finally
{
channel.Disconnect();
}
}
}
private QueuedBlockMsg ReadCompressedMsg(NetworkChannel netChan, NetworkChannelMessageHeader msgHdr)
{
byte[] networkReadWorkingBuf = this.m_networkReadWorkingBuf;
BlockModeCompressedDataMsg blockModeCompressedDataMsg = BlockModeCompressedDataMsg.ReadFromNet(netChan, networkReadWorkingBuf, 0);
byte[] array = null;
int num = 0;
int num2 = 0;
if (blockModeCompressedDataMsg.LogDataLength > 0)
{
this.GetAppendSpace(blockModeCompressedDataMsg.LogDataLength);
array = this.m_currentBuffer.Buffer;
num = this.m_currentBuffer.AppendOffset;
int num3 = blockModeCompressedDataMsg.LogDataLength;
int num4 = num;
foreach (int num5 in blockModeCompressedDataMsg.CompressedLengths)
{
num2 += num5;
netChan.Read(networkReadWorkingBuf, 0, num5);
int num6 = Math.Min(num3, 65536);
if (!Xpress.Decompress(networkReadWorkingBuf, 0, num5, array, num4, num6))
{
throw new NetworkCorruptDataException(this.m_netChannel.PartnerNodeName);
}
num3 -= num6;
num4 += num6;
}
this.m_currentBuffer.AppendOffset = num + blockModeCompressedDataMsg.LogDataLength;
}
return(new QueuedBlockMsg(blockModeCompressedDataMsg.EmitContext, array, num, num2)
{
RequestAckCounter = blockModeCompressedDataMsg.RequestAckCounter,
IOBuffer = this.m_currentBuffer
});
}
/// <summary>
/// 지정된 NetworkChannel만을 생성하고 네트워킹을 시작합니다.
/// sessionGenerator가 지정되기 때문에 config file에 정의된 sessionClass, receiveBufferSize는 무시됩니다.
/// </summary>
/// <param name="networkChannelName">시작할 NetworkChannel 이름</param>
/// <param name="sessionGenerator">Session 객체를 생성하는 Delegator</param>
/// <returns>해당 NetworkChannel 객체</returns>
public static NetworkChannel StartNetwork(String networkChannelName, SessionGenerateDelegator sessionGenerator)
{
ConfigNetworkChannel config = _listNetworkConfig.Find(v => v.NetworkChannelName == networkChannelName);
if (config == null)
{
throw new AegisException(AegisResult.InvalidArgument, "Invalid NetworkChannel name({0}).", networkChannelName);
}
NetworkChannel channel = NetworkChannel.CreateChannel(config.NetworkChannelName);
if (config.ListenIpAddress.Length == 0 || config.ListenPortNo == 0)
{
channel.StartNetwork(sessionGenerator, config.InitSessionPoolCount, config.MaxSessionPoolCount);
}
else
{
channel.StartNetwork(sessionGenerator, config.InitSessionPoolCount, config.MaxSessionPoolCount)
.OpenListener(config.ListenIpAddress, config.ListenPortNo);
}
return(channel);
}
/// <summary>
/// 创建网络频道。
/// </summary>
/// <param name="name">网络频道名称。</param>
/// <returns>要创建的网络频道。</returns>
public INetworkChannel CreateNetworkChannel(string name)
{
if (m_NetworkHelper == null)
{
throw new GameFrameworkException("You must set network helper first.");
}
if (HasNetworkChannel(name))
{
throw new GameFrameworkException(string.Format("Already exist network channel '{0}'.", name ?? string.Empty));
}
NetworkChannel networkChannel = new NetworkChannel(name, m_NetworkHelper);
networkChannel.NetworkChannelConnected += OnNetworkChannelConnected;
networkChannel.NetworkChannelClosed += OnNetworkChannelClosed;
networkChannel.NetworkChannelSended += OnNetworkChannelSended;
networkChannel.NetworkChannelReceived += OnNetworkChannelReceived;
networkChannel.NetworkChannelMissHeartBeat += OnNetworkChannelMissHeartBeat;
networkChannel.NetworkChannelError += OnNetworkChannelError;
networkChannel.NetworkChannelCustomError += OnNetworkChannelCustomError;
m_NetworkChannels.Add(name, networkChannel);
return(networkChannel);
}
internal BlockModeCompressedDataMsg(NetworkChannel channel, byte[] packetContent) : base(channel, NetworkChannelMessage.MessageType.BlockModeCompressedData, packetContent)
{
this.FlagsUsed = (BlockModeCompressedDataMsg.Flags)base.Packet.ExtractInt64();
this.RequestAckCounter = base.Packet.ExtractInt64();
this.LogDataLength = base.Packet.ExtractInt32();
if (this.LogDataLength > 1048576)
{
throw new NetworkCorruptDataException(channel.PartnerNodeName);
}
this.EmitContext = new JET_EMITDATACTX();
this.EmitContext.cbLogData = (long)this.LogDataLength;
this.EmitContext.dwVersion = base.Packet.ExtractInt32();
this.EmitContext.qwSequenceNum = base.Packet.ExtractUInt64();
this.EmitContext.grbitOperationalFlags = (ShadowLogEmitGrbit)base.Packet.ExtractUInt32();
this.EmitContext.logtimeEmit = base.Packet.ExtractDateTime();
JET_LGPOS lgposLogData = default(JET_LGPOS);
lgposLogData.lGeneration = base.Packet.ExtractInt32();
lgposLogData.isec = (int)base.Packet.ExtractUInt16();
lgposLogData.ib = (int)base.Packet.ExtractUInt16();
this.EmitContext.lgposLogData = lgposLogData;
if (this.LogDataLength > 0)
{
int num = BlockModeCompressedDataMsg.CalculateBlockCount(this.LogDataLength);
this.CompressedLengths = new int[num];
for (int i = 0; i < num; i++)
{
int num2 = base.Packet.ExtractInt32();
if (num2 <= 0 || num2 > 65536)
{
throw new NetworkCorruptDataException(channel.PartnerNodeName);
}
this.CompressedLengths[i] = num2;
}
}
}
public void ShouldReceiveOnParentWhenSent()
{
var parentAddress = new NodeAddress("parent");
var localAddress = new NodeAddress("local")
{
Parent = parentAddress
};
var data = NetworkChannel <string> .Serialize("Hello world");
var parent = new Mock <INode>();
parent.Setup(x => x.Address).Returns(parentAddress);
var network = new Mock <INetwork>();
network.Setup(x => x.FindOrDefault(null)).Returns((INode)null);
network.Setup(x => x.FindOrCreate(parentAddress)).Returns(parent.Object);
network.Setup(x => x.FindOrDefault(parentAddress)).Returns(parent.Object);
var local = new Node(localAddress, network.Object);
local.Send(typeof(string).ToString(), data, null);
parent.Verify(x => x.Send(typeof(string).ToString(), data, It.IsAny <NodeAddress>()), Times.Once());
}
internal SeedPageReaderSinglePageRequest(NetworkChannel channel, byte[] packetContent) : base(channel, NetworkChannelMessage.MessageType.SeedPageReaderSinglePageRequest, packetContent)
{
this.m_databaseName = base.Packet.ExtractString();
this.m_databasePath = base.Packet.ExtractString();
this.m_pageno = base.Packet.ExtractUInt32();
}
// Token: 0x060017B1 RID: 6065 RVA: 0x00061EC5 File Offset: 0x000600C5
internal NetworkChannelFileTransferReply(NetworkChannel channel, NetworkChannelMessage.MessageType msgType, byte[] packetContent) : base(channel, msgType, packetContent)
{
this.FileSize = base.Packet.ExtractInt64();
this.LastWriteUtc = base.Packet.ExtractDateTime();
this.DataEncoding = (NetworkChannel.DataEncodingScheme)base.Packet.ExtractUInt32();
}
internal SeedPageReaderSinglePageRequest(NetworkChannel channel, Guid databaseGuid, string databaseName, string databasePath, uint pageno) : base(channel, NetworkChannelMessage.MessageType.SeedPageReaderSinglePageRequest, databaseGuid)
{
this.m_databaseName = databaseName;
this.m_databasePath = databasePath;
this.m_pageno = pageno;
}
public PassiveReadRequest(PassiveBlockMode mgr, NetworkChannel channel)
{
this.Channel = channel;
this.Manager = mgr;
}
// Token: 0x060017AF RID: 6063 RVA: 0x00061E79 File Offset: 0x00060079
internal NetworkChannelFileTransferReply(NetworkChannel channel, NetworkChannelMessage.MessageType msgType) : base(channel, msgType)
{
this.m_dataEncoding = NetworkChannel.DataEncodingScheme.Uncompressed;
}
public override NetworkEvent PollEvent(out ulong clientId, out NetworkChannel channel, out ArraySegment <byte> payload, out float receiveTime)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_PollEvent.Begin();
#endif
try
{
Event @event;
if (host.CheckEvents(out @event) <= 0)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Service.Begin();
#endif
try
{
if (hasServiced || host.Service(0, out @event) <= 0)
{
clientId = 0;
channel = 0;
payload = new ArraySegment <byte>();
receiveTime = Time.realtimeSinceStartup;
return(NetworkEvent.Nothing);
}
hasServiced = true;
}
finally
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Service.End();
#endif
}
}
clientId = GetMLAPIClientId(@event.Peer.ID, false);
switch (@event.Type)
{
case EventType.Connect:
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Connect.Begin();
#endif
channel = 0;
payload = new ArraySegment <byte>();
receiveTime = Time.realtimeSinceStartup;
connectedEnetPeers.Add(@event.Peer.ID, @event.Peer);
@event.Peer.PingInterval(PingInterval);
@event.Peer.Timeout(TimeoutLimit, TimeoutMinimum, TimeoutMaximum);
if (connectTask != null)
{
connectTask.Success = true;
connectTask.IsDone = true;
connectTask = null;
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Connect.End();
#endif
return(NetworkEvent.Connect);
}
case EventType.Disconnect:
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Disconnect.Begin();
#endif
channel = 0;
payload = new ArraySegment <byte>();
receiveTime = Time.realtimeSinceStartup;
connectedEnetPeers.Remove(@event.Peer.ID);
if (connectTask != null)
{
connectTask.Success = false;
connectTask.IsDone = true;
connectTask = null;
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Disconnect.End();
#endif
return(NetworkEvent.Disconnect);
}
case EventType.Receive:
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Receive.Begin();
#endif
channel = channelIdToName[@event.ChannelID];
receiveTime = Time.realtimeSinceStartup;
int size = @event.Packet.Length;
if (size > messageBuffer.Length)
{
byte[] tempBuffer;
if (temporaryBufferReference != null && temporaryBufferReference.IsAlive && ((byte[])temporaryBufferReference.Target).Length >= size)
{
tempBuffer = (byte[])temporaryBufferReference.Target;
}
else
{
tempBuffer = new byte[size];
temporaryBufferReference = new WeakReference(tempBuffer);
}
@event.Packet.CopyTo(tempBuffer);
payload = new ArraySegment <byte>(tempBuffer, 0, size);
}
else
{
@event.Packet.CopyTo(messageBuffer);
payload = new ArraySegment <byte>(messageBuffer, 0, size);
}
@event.Packet.Dispose();
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Receive.End();
#endif
return(NetworkEvent.Data);
}
case EventType.Timeout:
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Timeout.Begin();
#endif
channel = 0;
payload = new ArraySegment <byte>();
receiveTime = Time.realtimeSinceStartup;
connectedEnetPeers.Remove(@event.Peer.ID);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_Timeout.End();
#endif
return(NetworkEvent.Disconnect);
}
case EventType.None:
default:
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_NoEvent.Begin();
#endif
channel = 0;
payload = new ArraySegment <byte>();
receiveTime = Time.realtimeSinceStartup;
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_NoEvent.End();
#endif
return(NetworkEvent.Nothing);
}
}
}
finally
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_PollEvent.End();
#endif
}
}
public override NetworkEvent PollEvent(out ulong clientId, out NetworkChannel networkChannel, out ArraySegment <byte> payload, out float receiveTime)
{
var eventType = RelayTransport.Receive(out int hostId, out int connectionId, out int channelId, m_MessageBuffer, m_MessageBuffer.Length, out int receivedSize, out byte error);
clientId = GetMLAPIClientId((byte)hostId, (ushort)connectionId, false);
receiveTime = UnityEngine.Time.realtimeSinceStartup;
var networkError = (NetworkError)error;
if (networkError == NetworkError.MessageToLong)
{
byte[] tempBuffer;
if (m_TemporaryBufferReference != null && m_TemporaryBufferReference.IsAlive && ((byte[])m_TemporaryBufferReference.Target).Length >= receivedSize)
{
tempBuffer = (byte[])m_TemporaryBufferReference.Target;
}
else
{
tempBuffer = new byte[receivedSize];
m_TemporaryBufferReference = new WeakReference(tempBuffer);
}
eventType = RelayTransport.Receive(out hostId, out connectionId, out channelId, tempBuffer, tempBuffer.Length, out receivedSize, out error);
payload = new ArraySegment <byte>(tempBuffer, 0, receivedSize);
}
else
{
payload = new ArraySegment <byte>(m_MessageBuffer, 0, receivedSize);
}
if (m_ChannelIdToName.TryGetValue(channelId, out NetworkChannel value))
{
networkChannel = value;
}
else
{
networkChannel = NetworkChannel.Internal;
}
if (m_ConnectTask != null && hostId == m_ServerHostId && connectionId == m_ServerConnectionId)
{
if (eventType == NetworkEventType.ConnectEvent)
{
// We just got a response to our connect request.
m_ConnectTask.Message = null;
m_ConnectTask.SocketError = networkError == NetworkError.Ok ? System.Net.Sockets.SocketError.Success : System.Net.Sockets.SocketError.SocketError;
m_ConnectTask.State = null;
m_ConnectTask.Success = networkError == NetworkError.Ok;
m_ConnectTask.TransportCode = (byte)networkError;
m_ConnectTask.TransportException = null;
m_ConnectTask.IsDone = true;
m_ConnectTask = null;
}
else if (eventType == NetworkEventType.DisconnectEvent)
{
// We just got a response to our connect request.
m_ConnectTask.Message = null;
m_ConnectTask.SocketError = System.Net.Sockets.SocketError.SocketError;
m_ConnectTask.State = null;
m_ConnectTask.Success = false;
m_ConnectTask.TransportCode = (byte)networkError;
m_ConnectTask.TransportException = null;
m_ConnectTask.IsDone = true;
m_ConnectTask = null;
}
}
if (networkError == NetworkError.Timeout)
{
// In UNET. Timeouts are not disconnects. We have to translate that here.
eventType = NetworkEventType.DisconnectEvent;
}
// Translate NetworkEventType to NetEventType
switch (eventType)
{
case NetworkEventType.DataEvent:
return(NetworkEvent.Data);
case NetworkEventType.ConnectEvent:
return(NetworkEvent.Connect);
case NetworkEventType.DisconnectEvent:
return(NetworkEvent.Disconnect);
case NetworkEventType.Nothing:
return(NetworkEvent.Nothing);
case NetworkEventType.BroadcastEvent:
return(NetworkEvent.Nothing);
}
return(NetworkEvent.Nothing);
}
// Token: 0x060019EE RID: 6638 RVA: 0x0006C6D4 File Offset: 0x0006A8D4
internal CancelCiFileReply(NetworkChannel channel, byte[] packetContent) : base(channel, NetworkChannelMessage.MessageType.CancelCiFileReply, packetContent)
{
}
// Token: 0x060019ED RID: 6637 RVA: 0x0006C6C6 File Offset: 0x0006A8C6
internal CancelCiFileReply(NetworkChannel channel) : base(channel, NetworkChannelMessage.MessageType.CancelCiFileReply)
{
}
public ServerConnection(string ip, int port)
{
this.server = new NetworkChannel (ip, port);
this.server.SetNotifier (this);
this.server.Start ();
}
