void OnConnectedInternal(TCPConnection connection)
{
if (connection == null)
{
return;
}
connection.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
lock (this)
{
ComSnowballNode node = new ComSnowballNode(connection);
if (nodeTcpMap.ContainsKey(node.TcpEndPoint))
{
Disconnect(node);
}
else
{
nodeTcpMap.Add(node.TcpEndPoint, node);
node.HealthLostCount = 0;
connection.OnDisconnected = OnDisconnectedInternal;
connection.OnPoll = OnPoll;
}
//Util.Log("Server:Connected");
}
}
void OnDisconnectedInternal(TCPConnection connection)
{
lock (this)
{
ComNode n;
if (nodeTcpMap.TryGetValue((IPEndPoint)connection.EndPoint, out n))
{
ComSnowballNode node = (ComSnowballNode)n;
if (nodeTcpMap.ContainsKey(connection.EndPoint))
{
nodeTcpMap.Remove((IPEndPoint)connection.EndPoint);
}
try
{
userNodeMapLock.AcquireWriterLock(1000);
if (userNodeMap.ContainsKey(node.UserId))
{
userNodeMap.Remove(node.UserId);
}
}
finally
{
userNodeMapLock.ReleaseWriterLock();
}
node.DisconnectedTimeStamp = DateTime.Now;
try
{
disconnectedUserNodeMapLock.AcquireWriterLock(1000);
if (!disconnectedUserNodeMap.ContainsKey(node.UserId))
{
disconnectedUserNodeMap.Add(node.UserId, node);
}
}
finally
{
disconnectedUserNodeMapLock.ReleaseWriterLock();
}
if (node.UdpEndPoint != null && nodeUdpMap.ContainsKey(node.UdpEndPoint))
{
nodeUdpMap.Remove(node.UdpEndPoint);
}
node.UdpEndPoint = null;
node.IsDisconnecting = false;
node.IsConnected = false;
if (OnDisconnected != null)
{
OnDisconnected(node);
}
}
}
}
public async Task <bool> Broadcast <T>(ComGroup group, short channelId, T data, ComNode exception = null)
{
IDataChannel channel;
if (!dataChannelMap.TryGetValue(channelId, out channel))
{
return(false);
}
bool isRent = false;
byte[] buffer = null;
int bufferSize = 0;
if (channel.Encryption == Encryption.None)
{
BuildBuffer(channel, data, ref buffer, ref bufferSize, ref isRent, null);
}
foreach (var node in group)
{
if (node == exception)
{
continue;
}
if (!nodeTcpMap.ContainsKey(node.TcpEndPoint))
{
continue;
}
if (channel.Encryption == Encryption.Aes)
{
BuildBuffer(channel, data, ref buffer, ref bufferSize, ref isRent, node.AesEncrypter);
}
ComSnowballNode snode = (ComSnowballNode)node;
if (channel.Qos == QosType.Reliable)
{
await snode.Connection.Send(bufferSize, buffer);
}
else if (channel.Qos == QosType.Unreliable)
{
if (snode.UdpEndPoint != null)
{
await udpTerminal.Send(snode.Ip, snode.UdpEndPoint.Port, bufferSize, buffer);
}
}
}
if (isRent)
{
arrayPool.Return(buffer);
}
return(true);
}
async Task <bool> SendInternal <T>(ComNode node, short channelId, T data)
{
return(await Task.Run(async() =>
{
if (!nodeTcpMap.ContainsKey(node.TcpEndPoint))
{
return false;
}
IDataChannel channel;
if (!dataChannelMap.TryGetValue(channelId, out channel))
{
return false;
}
bool isRent = false;
byte[] buffer = null;
int bufferSize = 0;
IEncrypter encrypter = null;
if (channel.Encryption == Encryption.Aes)
{
encrypter = node.AesEncrypter;
}
BuildBuffer(channel, data, ref buffer, ref bufferSize, ref isRent, encrypter);
ComSnowballNode snode = (ComSnowballNode)node;
if (channel.Qos == QosType.Reliable)
{
await snode.Connection.Send(bufferSize, buffer).ConfigureAwait(false);
}
else if (channel.Qos == QosType.Unreliable)
{
if (snode.UdpEndPoint != null)
{
await udpTerminal.Send(snode.Ip, snode.UdpEndPoint.Port, bufferSize, buffer).ConfigureAwait(false);
}
}
if (isRent)
{
arrayPool.Return(buffer);
}
return true;
}).ConfigureAwait(false));
}
public bool Disconnect(ComNode node)
{
if (!node.IsDisconnecting && nodeTcpMap.ContainsKey(node.TcpEndPoint))
{
node.IsDisconnecting = true;
ComSnowballNode snode = (ComSnowballNode)node;
snode.Connection.Disconnect();
return(true);
}
else
{
return(false);
}
}
void OnUnreliableReceived(IPEndPoint endPoint, byte[] data, int size)
{
int head = 0;
while (head < size)
{
BytePacker packer = new BytePacker(data);
short datasize = packer.ReadShort();
#if DISABLE_CHANNEL_VARINT
short channelId = packer.ReadShort();
#else
int s = 0;
short channelId = VarintBitConverter.ToShort(packer, out s);
#endif
IDataChannel channel;
if (dataChannelMap.TryGetValue(channelId, out channel))
{
if (channelId == (short)PreservedChannelId.Beacon)
{
}
else if (channelId == (short)PreservedChannelId.UdpNotify)
{
IssueIdData idData = (IssueIdData)channel.FromStream(ref packer);
try
{
userNodeMapLock.AcquireReaderLock(1000);
ComNode n;
if (userNodeMap.TryGetValue(idData.Id, out n))
{
//Util.Log("UdpUserName:" + userName);
ComSnowballNode node = (ComSnowballNode)n;
if (node.UdpEndPoint == null && node.AesDecrypter != null)
{
byte[] decrypted = node.AesDecrypter.Decrypt(idData.encryptionData);
if (decrypted.SequenceEqual(Global.UdpRawData))
{
node.UdpEndPoint = endPoint;
if (nodeUdpMap.ContainsKey(endPoint))
{
nodeUdpMap.Remove(endPoint);
}
nodeUdpMap.Add(endPoint, node);
SendInternal(node, (short)PreservedChannelId.UdpNotifyAck, endPoint.Port);
byte[] key = GenerateTmpKey();
node.TmpKey = key;
SendInternal(node, (short)PreservedChannelId.Health, key);
node.IsConnected = true;
if (OnConnected != null)
{
OnConnected(node);
}
}
}
}
}
finally
{
userNodeMapLock.ReleaseReaderLock();
}
}
else
{
if (channel.CheckMode == CheckMode.Sequre || channel.Encryption == Encryption.Aes)
{
ComNode node;
if (nodeUdpMap.TryGetValue(endPoint, out node))
{
IDecrypter decrypter = null;
if (channel.Encryption == Encryption.Rsa)
{
decrypter = rsaDecrypter;
}
else if (channel.Encryption == Encryption.Aes)
{
decrypter = node.AesDecrypter;
}
object container = channel.FromStream(ref packer, decrypter);
channel.Received(node, container);
}
}
else
{
IDecrypter decrypter = null;
if (channel.Encryption == Encryption.Rsa)
{
decrypter = rsaDecrypter;
}
object container = channel.FromStream(ref packer, decrypter);
channel.Received(null, container);
}
}
}
head += datasize + 4;
}
}
