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); }