protected override void OnRawMessageReceived(TcpRawMessageReceivedEventArgs args)
{
if (ReceivedMessageFilter(args))
{
return;
}
MessageReceived?.Invoke(this, args);
}
protected virtual bool ReceivedMessageFilter(TcpRawMessageReceivedEventArgs tcpRawMessageArgs)
{
return(false);
}
protected virtual void OnRawMessageReceived(TcpRawMessageReceivedEventArgs args)
{
}
private void ProcessReceive(SocketAsyncEventArgs sockAsyncArgs)
{
if (!_isRunning)
{
return;
}
long clientID = (long)sockAsyncArgs.UserToken;
if (!_clients.TryGetValue(clientID, out ClientContext clientContext))
{
return;
}
Socket sockClient = clientContext.ClientSocket;
if (sockAsyncArgs.SocketError == SocketError.Success)
{
int recvCount = sockAsyncArgs.BytesTransferred;
if (recvCount > 0)
{
RingQueue clientRingBuffer = clientContext.ReceiveBuffer;
clientRingBuffer.Write(sockAsyncArgs.Buffer, sockAsyncArgs.Offset, recvCount);
//speed limit
if (clientContext.RecvSpeedController != null)
{
clientContext.RecvSpeedController.TryLimit(recvCount);
}
//try get a completed packet
List <DataPacket> messageList = null;
int endPos = 0;
try
{
messageList = _packetSpliter.GetPackets(clientRingBuffer.Buffer, 0, clientRingBuffer.DataLength, clientID, out endPos);
}
catch (NotImplementedException)
{
clientRingBuffer.Clear();
}
catch (Exception ex)
{
TcpRawMessageReceivedEventArgs rawMessage = new TcpRawMessageReceivedEventArgs()
{
Message = null,
Error = ex,
ClientID = clientID
};
OnRawMessageReceived(rawMessage);
}
if (messageList != null)
{
try
{
clientRingBuffer.Remove(endPos);
foreach (DataPacket messageSegment in messageList)
{
clientContext.RecvRawMessage.ClientID = (long)sockClient.Handle;
clientContext.RecvRawMessage.MessageRawData = messageSegment.Data;
clientContext.RecvRawMessage.Tag = messageSegment.Tag;
TcpRawMessageReceivedEventArgs rawMessage = new TcpRawMessageReceivedEventArgs()
{
Message = clientContext.RecvRawMessage,
ClientID = clientID
};
OnRawMessageReceived(rawMessage);
}
}
catch (InvalidPacketException)
{
//invalid data received , indicates the client has made a illegal connection, we should disconnect it.
_logger?.Info("illegal connection detected");
if (_isRunning)
{
CloseClient(true, (long)sockClient.Handle);
}
return;
}
catch (Exception ex)
{
_logger?.Warn("an error has occurred during get packets", ex.Message);
}
}
//in case of the socket is closed, the following statements may cause of exception, so we should use try catch
try
{
if (!clientContext.ClientSocket.ReceiveAsync(sockAsyncArgs))
{
ProcessReceive(sockAsyncArgs);
}
}
catch { }
}
else
{
_logger?.Warn($"sockAsyncArgs got an error: {sockAsyncArgs.SocketError.ToString()}");
if (_isRunning)
{
CloseClient(true, clientID);
}
}
}
else
{
if (_isRunning)
{
CloseClient(true, clientID);
}
}
}
protected override void OnRawMessageReceived(TcpRawMessageReceivedEventArgs args)
{
if (args.Error == null)
{
ArraySegment <byte> rawSegment = args.Message.MessageRawData;
if (rawSegment.Count >= 4)
{
UInt32 specialMark = BitConverter.ToUInt32(rawSegment.Array, rawSegment.Offset);
if (specialMark == TcpUtility.JOIN_GROUP_MARK)
{
if (!EnableGroup)
{
return;
}
JoinGroupMessage joinGroupMsg = null;
if (!JoinGroupMessage.TryParse(rawSegment, out joinGroupMsg))
{
return;
}
if (_clients.TryGetValue(args.Message.ClientID, out ClientContext clientContext))
{
clientContext.Groups = joinGroupMsg.GroupSet;
AddClientToGroup(clientContext);
}
return;
}
else if (specialMark == TcpUtility.GROUP_TRANSMIT_MSG_MARK ||
specialMark == TcpUtility.GROUP_TRANSMIT_MSG_LOOP_BACK_MARK)
{
bool loopBack = specialMark == TcpUtility.GROUP_TRANSMIT_MSG_LOOP_BACK_MARK;
if (!EnableGroup)
{
return;
}
GroupTransmitMessage transPacket = null;
if (!GroupTransmitMessage.TryParse(rawSegment, out transPacket))
{
return;
}
try
{
if (!ServerConfig.AllowCrossGroupMessage)
{
ClientContext sourceClient = GetClient(args.Message.ClientID);
if (sourceClient == null || sourceClient.Groups == null || sourceClient.Groups.Count == 0)
{
return;
}
foreach (string groupName in transPacket.GroupNameCollection)
{
if (!sourceClient.Groups.Contains(groupName))
{
return;
}
}
}
SendGroupMessageAsync(transPacket.GroupNameCollection, transPacket.TransMessageData.Array, transPacket.TransMessageData.Offset, transPacket.TransMessageData.Count
, loopBack ? -1 : args.Message.ClientID);
}
catch (Exception ex)
{
_logger?.Warn("Transmit group message exception.", ex.Message);
}
return;
}
}
if (ReceivedMessageFilter(args))
{
return;
}
}
MessageReceived?.Invoke(this, args);
return;
}
