public bool Start()
{
if (_running)
{
return(false);
}
try
{
_client.Connect(_ioServerAddress, _port);
}
catch
{
return(false);
}
RecvContext c = new RecvContext();
c.client = _client;
c.callback = _recvCallback;
_recvThread = new Thread(RecvThread);
_recvThread.Start(c);
_running = true;
return(true);
}
public void RmiMessage(IChannelHandlerContext context, RmiMessage message, RecvContext recvContext)
{
var buffer = Unpooled.WrappedBuffer(message.Data);
recvContext.Message = buffer;
context.FireChannelRead(recvContext);
}
public void PushRecvContext(RecvContext recvContext)
{
lock (moRecvQueue)
{
recvContext.RecvBuff = null;
recvContext.uUserSock = null;
m_queueRecvContext.Enqueue(recvContext);
}
}
/// <summary>
/// 接收
/// </summary>
/// <param name="ar"></param>
public static void Receive(IAsyncResult ar)
{
RecvContext recvContext = (RecvContext)ar.AsyncState;
UserSock self = recvContext.uUserSock;
if (self.m_State == SockState.Idle)
{
return;
}
int size = 0;
try
{
size = self.m_Socket.EndReceive(ar);
if (size == 0)
{
size = -1;
}
}
catch (SocketException e)
{
if (self.m_Socket.Connected)
{
if (e.ErrorCode == 10035)
{
size = 0;
}
else
{
size = -1;
self.SetSockError(e.ErrorCode, e.ToString());
}
}
}
catch (Exception e)
{
size = -1;
if (self.m_Socket.Connected)
{
self.SetSockError(0, e.ToString());
}
}
finally
{
}
self.StopReceive(recvContext.RecvBuff, size);
self.PushRecvContext(recvContext);
}
/// <summary>
/// 开始接收数据
/// </summary>
/// <returns></returns>
private bool StartReceive()
{
if (m_Socket != null)
{
try
{
RecvContext recvContext = GetRecvContext(this, m_AsyncEvent.GetBufferData());
AsyncCallback asynccallback = SockAsync.Receive;
m_Socket.BeginReceive(recvContext.RecvBuff.m_abyRecvBuffer, 0, AsyncEvent.ASYNCRECVBUF_LENGTH,
SocketFlags.None, asynccallback, recvContext);
}
catch (SocketException e)
{
///接收中出错，关闭
SetSockError(e.ErrorCode, e.ToString());
SetSockState(SockState.Failed);
return(false);
}
return(true);
}
return(false);
}
public RecvContext GetRecvContext(UserSock uSock, AsyncEvent.RecvBufferData recvBuff)
{
RecvContext recvContext = null;
lock (moRecvQueue)
{
if (m_queueRecvContext.Count > 0)
{
recvContext = m_queueRecvContext.Dequeue();
}
}
if (recvContext == null)
{
recvContext = new RecvContext(uSock, recvBuff);
}
else
{
recvContext.uUserSock = uSock;
recvContext.RecvBuff = recvBuff;
}
return(recvContext);
}
private static void RecvThread(object c)
{
ChuniIoMessage message = new ChuniIoMessage();
int sz = Marshal.SizeOf(message);
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 0);
IntPtr recvBufferPtr;
recvBufferPtr = Marshal.AllocHGlobal(32);
RecvContext context = (RecvContext)c;
try
{
while (true)
{
byte[] recvBuffer = context.client.Receive(ref endpoint);
if (recvBuffer.Length == 0)
{
break;
}
if (recvBuffer.Length != sz)
{
continue;
}
Marshal.Copy(recvBuffer, 0, recvBufferPtr, sz);
message = (ChuniIoMessage)Marshal.PtrToStructure(recvBufferPtr, message.GetType());
context.callback(message);
}
}
catch
{
// noting, just exit.
}
Marshal.FreeHGlobal(recvBufferPtr);
}
public void UnreliablePingHandler(ProudSession session, UnreliablePingMessage message, RecvContext recvContext)
{
session.UnreliablePing = TimeSpan.FromSeconds(message.Ping).TotalMilliseconds;
if (recvContext.UdpEndPoint != null)
{
session.LastUdpPing = DateTimeOffset.Now;
}
var ts = DateTime.Now - _startTime.Value;
session.SendUdpIfAvailableAsync(new UnreliablePongMessage(message.ClientTime, ts.TotalSeconds));
}
public void EncryptedReliableMessage(IChannelHandlerContext context, ProudSession session, EncryptedReliableMessage message, RecvContext recvContext)
{
var crypt = session.Crypt;
if (crypt == null)
{
return;
}
var buffer = context.Allocator.Buffer(message.Data.Length);
using (var src = new MemoryStream(message.Data))
using (var dst = new WriteOnlyByteBufferStream(buffer, false))
{
crypt.Decrypt(context.Allocator, message.EncryptMode, src, dst, true);
}
recvContext.Message = buffer;
context.Channel.Pipeline.Context <ProudFrameDecoder>().FireChannelRead(recvContext);
}
public void CompressedMessage(IChannelHandlerContext context, CompressedMessage message, RecvContext recvContext)
{
var decompressed = message.Data.DecompressZLib();
recvContext.Message = Unpooled.WrappedBuffer(decompressed);
context.Channel.Pipeline.Context <ProudFrameDecoder>().FireChannelRead(recvContext);
}
public void PeerUdp_ServerHolepunch(ProudSession session, PeerUdp_ServerHolepunchMessage message, RecvContext recvContext)
{
session.Logger?.Debug("PeerUdp_ServerHolepunch={@Message}", message);
if (!session.UdpEnabled || !_server.UdpSocketManager.IsRunning)
{
return;
}
var target = session.P2PGroup?.Members.GetValueOrDefault(message.HostId)?.Session;
if (target == null || !target.UdpEnabled)
{
return;
}
session.SendUdpAsync(new PeerUdp_ServerHolepunchAckMessage(message.MagicNumber, recvContext.UdpEndPoint, target.HostId));
}
public override void ChannelRead(IChannelHandlerContext context, object obj)
{
var message = obj as UdpMessage;
Debug.Assert(message != null);
var log = _server.Configuration.Logger?
.ForContext("EndPoint", message.EndPoint.ToString());
try
{
var session = _server.SessionsByUdpId.GetValueOrDefault(message.SessionId);
if (session == null)
{
if (message.Content.GetByte(0) != (byte)ProudCoreOpCode.ServerHolepunch)
{
log?.Warning("Expected ServerHolepunch as first udp message but got {MessageType}", (ProudCoreOpCode)message.Content.GetByte(0));
return;
}
var holepunch = (ServerHolepunchMessage)CoreMessageDecoder.Decode(message.Content);
// TODO add a lookup by holepunch magic
session = _server.Sessions.Values.FirstOrDefault(x =>
x.HolepunchMagicNumber.Equals(holepunch.MagicNumber));
if (session == null)
{
log?.Warning("Invalid holepunch magic number");
return;
}
if (session.UdpSocket != _socket)
{
log?.Warning("Client is sending to the wrong udp socket");
return;
}
session.UdpSessionId = message.SessionId;
session.UdpEndPoint = message.EndPoint;
_server.SessionsByUdpId[session.UdpSessionId] = session;
session.SendUdpAsync(new ServerHolepunchAckMessage(session.HolepunchMagicNumber, session.UdpEndPoint));
return;
}
if (session.UdpSocket != _socket)
{
log?.Warning("Client is sending to the wrong udp socket");
return;
}
var recvContext = new RecvContext
{
Message = message.Content.Retain(),
UdpEndPoint = message.EndPoint
};
session.Channel.Pipeline.Context <RecvContextDecoder>().FireChannelRead(recvContext);
}
finally
{
message.Content.Release();
}
}
public void EncryptedReliableMessage(IChannelHandlerContext context, ProudSession session, EncryptedReliableMessage message, RecvContext recvContext)
{
Crypt crypt;
// TODO Decrypt P2P
//if (message.IsRelayed)
//{
// //var remotePeer = (ServerRemotePeer)session.P2PGroup?.Members.GetValueOrDefault(message.TargetHostId);
// //if (remotePeer == null)
// // return;
// //encryptContext = remotePeer.EncryptContext;
// //if (encryptContext == null)
// // throw new ProudException($"Received encrypted message but the remote peer has no encryption enabled");
//}
//else
{
crypt = session.Crypt;
}
var buffer = context.Allocator.Buffer(message.Data.Length);
using (var src = new MemoryStream(message.Data))
using (var dst = new WriteOnlyByteBufferStream(buffer, false))
crypt.Decrypt(context.Allocator, message.EncryptMode, src, dst, true);
recvContext.Message = buffer;
context.Channel.Pipeline.Context <ProudFrameDecoder>().FireChannelRead(recvContext);
}
