public bool ClientReceive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (clientPeer == null)
{
return(false);
}
clientPeer.Recv();
if (clientPeer.eventQueue.Count == 0)
{
return(false);
}
if (!clientPeer.eventQueue.TryDequeue(out eventData))
{
return(false);
}
switch (eventData.type)
{
case ENetworkEvent.DisconnectEvent:
// Disconnect from server
StopClient();
break;
case ENetworkEvent.ErrorEvent:
// Disconnect from server
StopClient();
break;
}
return(true);
}
private void HandleRecvData(byte[] buffer, int length, TransportEventData eventData)
{
recvReader.Clear();
recvReader.SetSource(buffer, 0, length);
eventData.type = (ENetworkEvent)recvReader.GetByte();
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
// This must received at clients only, then create new kcp here
clientConnId = recvReader.GetUInt();
int remotePort = recvReader.GetInt();
eventData.connectionId = clientConnId;
eventQueue.Enqueue(eventData);
kcpHandles[clientConnId] = CreateKcp(clientConnId, clientSetting);
kcpHandles[clientConnId].remoteEndPoint = new IPEndPoint(eventData.endPoint.Address, remotePort);
break;
case ENetworkEvent.DataEvent:
// Read remaining data
eventData.reader = new NetDataReader(recvReader.GetRemainingBytes());
eventQueue.Enqueue(eventData);
break;
case ENetworkEvent.DisconnectEvent:
// This must received at clients only to force them to stop client
eventQueue.Enqueue(eventData);
break;
}
}
private void RecvConnection()
{
if (connectSocket == null ||
(!connectSocket.IsBound && !connectSocket.Connected))
{
return;
}
if (!connectSocket.Poll(0, SelectMode.SelectRead))
{
return;
}
EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
int recvLength;
try
{
recvLength = connectSocket.Receive(recvBuffer, 0, recvBuffer.Length, SocketFlags.None);
endPoint = connectSocket.RemoteEndPoint;
}
catch (SocketException ex)
{
HandleError(endPoint, ex.SocketErrorCode);
return;
}
// Handle data directly for connect socket, not have to set kcp input (and read later)
TransportEventData eventData = default(TransportEventData);
eventData.endPoint = (IPEndPoint)endPoint;
HandleRecvData(recvBuffer, recvLength, eventData);
}
public override void OnServerReceive(TransportEventData eventData)
{
CentralServerPeerInfo tempPeerInfo;
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
Logging.Log(LogTag, "OnPeerConnected peer.ConnectionId: " + eventData.connectionId);
ConnectionIds.Add(eventData.connectionId);
break;
case ENetworkEvent.DataEvent:
ReadPacket(eventData.connectionId, eventData.reader);
break;
case ENetworkEvent.DisconnectEvent:
Logging.Log(LogTag, "OnPeerDisconnected peer.ConnectionId: " + eventData.connectionId + " disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
ConnectionIds.Remove(eventData.connectionId);
// Remove disconnect map spawn server
MapSpawnServerPeers.Remove(eventData.connectionId);
// Remove disconnect map server
if (MapServerPeers.TryGetValue(eventData.connectionId, out tempPeerInfo))
{
MapServerPeersByMapId.Remove(tempPeerInfo.extra);
MapServerPeersByInstanceId.Remove(tempPeerInfo.extra);
MapServerPeers.Remove(eventData.connectionId);
RemoveMapUsers(eventData.connectionId);
}
break;
case ENetworkEvent.ErrorEvent:
Logging.LogError(LogTag, "OnPeerNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError + " errorMessage " + eventData.errorMessage);
break;
}
}
public override void OnClientReceive(TransportEventData eventData)
{
#if UNITY_STANDALONE && !CLIENT_BUILD
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
Logging.Log(LogTag, "OnClientConnected");
OnConnectedToClusterServer();
break;
case ENetworkEvent.DataEvent:
ReadPacket(-1, eventData.reader);
break;
case ENetworkEvent.DisconnectEvent:
Logging.Log(LogTag, "OnClientDisconnected peer. disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
StopClient();
OnDisconnectedFromClusterServer().Forget();
break;
case ENetworkEvent.ErrorEvent:
Logging.LogError(LogTag, "OnClientNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError + " errorMessage " + eventData.errorMessage);
break;
}
#endif
}
private void RecvData()
{
if (dataSocket == null)
{
return;
}
if (!dataSocket.Poll(0, SelectMode.SelectRead))
{
return;
}
EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
int recvLength;
try
{
recvLength = dataSocket.ReceiveFrom(recvBuffer, 0, recvBuffer.Length, SocketFlags.None, ref endPoint);
}
catch (SocketException ex)
{
HandleError(endPoint, ex.SocketErrorCode);
return;
}
recvReader.Clear();
recvReader.SetSource(recvBuffer, 0, recvLength);
uint connectionId = recvReader.GetUInt();
// Have to find which kcp send this data, then set its input
KCPHandle kcpHandle = null;
if (kcpHandles.TryGetValue(connectionId, out kcpHandle))
{
kcpHandle.remoteEndPoint = endPoint;
kcpHandle.kcp.Input(new Span <byte>(recvBuffer, 0, recvLength));
byte[] kcpData;
while ((recvLength = kcpHandle.kcp.PeekSize()) > 0)
{
kcpData = new byte[recvLength];
if (kcpHandle.kcp.Recv(kcpData) >= 0)
{
TransportEventData eventData = default(TransportEventData);
eventData.connectionId = connectionId;
eventData.endPoint = (IPEndPoint)endPoint;
HandleRecvData(kcpData, recvLength, eventData);
}
}
}
}
public bool ServerReceive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (server == null)
{
return(false);
}
Event tempNetEvent;
byte[] tempBuffers;
server.Service(0, out tempNetEvent);
switch (tempNetEvent.Type)
{
case EventType.None:
return(false);
case EventType.Connect:
eventData.type = ENetworkEvent.ConnectEvent;
eventData.connectionId = tempNetEvent.Peer.ID;
serverPeers[tempNetEvent.Peer.ID] = tempNetEvent.Peer;
break;
case EventType.Disconnect:
eventData.type = ENetworkEvent.DisconnectEvent;
eventData.connectionId = tempNetEvent.Peer.ID;
serverPeers.Remove(tempNetEvent.Peer.ID);
break;
case EventType.Timeout:
eventData.type = ENetworkEvent.DisconnectEvent;
eventData.connectionId = tempNetEvent.Peer.ID;
eventData.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.Timeout
};
serverPeers.Remove(tempNetEvent.Peer.ID);
break;
case EventType.Receive:
tempBuffers = new byte[tempNetEvent.Packet.Length];
tempNetEvent.Packet.CopyTo(tempBuffers);
eventData.type = ENetworkEvent.DataEvent;
eventData.connectionId = tempNetEvent.Peer.ID;
eventData.reader = new NetDataReader(tempBuffers);
tempNetEvent.Packet.Dispose();
break;
}
return(true);
}
public bool ClientReceive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (Client == null)
{
return(false);
}
if (clientEventQueue.Count == 0)
{
return(false);
}
eventData = clientEventQueue.Dequeue();
return(true);
}
public bool ServerReceive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (serverPeer == null)
{
return(false);
}
serverPeer.Recv();
if (serverPeer.eventQueue.Count == 0)
{
return(false);
}
return(serverPeer.eventQueue.TryDequeue(out eventData));
}
public bool ServerReceive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (Server == null)
{
return(false);
}
if (serverEventQueue.Count == 0)
{
return(false);
}
eventData = serverEventQueue.Dequeue();
if (eventData.type == ENetworkEvent.DataEvent && eventData.reader == null)
{
return(false);
}
return(true);
}
public override bool Receive(out TransportEventData eventData)
{
eventData = default(TransportEventData);
if (netManager == null)
{
return(false);
}
netManager.PollEvents();
if (qEventQueue.Count == 0)
{
return(false);
}
eventData = qEventQueue.Dequeue();
return(true);
}
private void HandleError(EndPoint endPoint, SocketError socketErrorCode)
{
switch (socketErrorCode)
{
case SocketError.Interrupted:
case SocketError.NotSocket:
case SocketError.ConnectionReset:
case SocketError.MessageSize:
case SocketError.TimedOut:
// Ignored error
break;
default:
// Store error event to queue
TransportEventData eventData = default(TransportEventData);
eventData.type = ENetworkEvent.ErrorEvent;
eventData.endPoint = (IPEndPoint)endPoint;
eventData.socketError = socketErrorCode;
eventQueue.Enqueue(eventData);
break;
}
}
public override void OnClientReceive(TransportEventData eventData)
{
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
Debug.Log("CentralAppServerRegister::OnPeerConnected.");
OnCentralServerConnected();
break;
case ENetworkEvent.DataEvent:
ReadPacket(eventData.connectionId, eventData.reader);
break;
case ENetworkEvent.DisconnectEvent:
Debug.Log("CentralAppServerRegister::OnPeerDisconnected. disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
OnCentralServerDisconnected(eventData.disconnectInfo);
break;
case ENetworkEvent.ErrorEvent:
Debug.LogError("CentralAppServerRegister::OnNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError);
break;
}
}
public override void OnClientReceive(TransportEventData eventData)
{
switch (eventData.type)
{
case ENetworkEvent.ConnectEvent:
Logging.Log(LogTag, "OnPeerConnected.");
OnCentralServerConnected();
break;
case ENetworkEvent.DataEvent:
ReadPacket(eventData.connectionId, eventData.reader);
break;
case ENetworkEvent.DisconnectEvent:
Logging.Log(LogTag, "OnPeerDisconnected. disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
StopClient();
OnCentralServerDisconnected(eventData.disconnectInfo).Forget();
break;
case ENetworkEvent.ErrorEvent:
Logging.LogError(LogTag, "OnNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError);
break;
}
}
public abstract bool Receive(out TransportEventData eventData);
public TransportEventData GetDisconnectEvent(ushort connectionId, bool localDisconnect, SocketError error)
{
TransportEventData result = new TransportEventData()
{
type = ENetworkEvent.DisconnectEvent,
connectionId = connectionId,
};
if (localDisconnect)
{
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.DisconnectPeerCalled,
SocketErrorCode = error,
};
}
else
{
switch (error)
{
case SocketError.ConnectionReset:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.ConnectionFailed,
SocketErrorCode = error,
};
break;
case SocketError.TimedOut:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.Timeout,
SocketErrorCode = error,
};
break;
case SocketError.HostUnreachable:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.HostUnreachable,
SocketErrorCode = error,
};
break;
case SocketError.NetworkUnreachable:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.NetworkUnreachable,
SocketErrorCode = error,
};
break;
case SocketError.ConnectionAborted:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.RemoteConnectionClose,
SocketErrorCode = error,
};
break;
case SocketError.ConnectionRefused:
result.disconnectInfo = new DisconnectInfo()
{
Reason = DisconnectReason.ConnectionRejected,
SocketErrorCode = error,
};
break;
default:
result.disconnectInfo = new DisconnectInfo()
{
SocketErrorCode = error,
};
break;
}
}
return(result);
}