private async Task ReadLoop(CancellationToken ct) { while (!ct.IsCancellationRequested) { while (_client.Available <= 0) { await Task.Delay(10); } int length; byte[] data; await _streamSemaphore.WaitAsync(ct); try { length = Protocol.LengthHeader.Read(_stream); data = new byte[length]; await _stream.ReadAsync(data, 0, length); } finally { _streamSemaphore.Release(); } using (var stream = new MemoryStream(data)) { var id = Protocol.IdHeader.Read(stream); var packetDef = Protocol.IdResolver.MapIdToPacket(id); var obj = packetDef.ReadDelegate(stream); OnPacketReceived?.Invoke(obj, packetDef.Binding); } } }
private async Task Receive(CancellationToken cancelToken = default) { Console.WriteLine($"Start Receiving"); while (_isConnected) { await CloseIfCanceled(cancelToken); byte[] sizeBytes = await ReadBytes(4, cancelToken); int size; try { size = BitConverter.ToInt32(sizeBytes, 0); } catch (Exception e) { Console.WriteLine(e); await CloseAsync(); throw; } Console.WriteLine($"New Message incoming: {size} bytes"); byte[] packetBytes = await ReadBytes(size, cancelToken); Packet packet = MessagePackSerializer.Deserialize <Packet>(packetBytes); OnPacketReceived?.Invoke(packet); } }
private void v_HandlePacket(NetIncomingMessage msg) { try { IPacket packet = DeserializePacket(msg); if (packet is null) { throw new Exception("Tried to parse a IPacket, but failed"); } OnPacketReceived?.Invoke(packet); m_callbackRegistry.HandlePacket(packet); if (packet is DataPacket dataPacket) { OnDataPacketReceived?.Invoke(dataPacket); } else if (packet is RequestPacket requestPacket) { OnRequestPacketReceived?.Invoke(requestPacket); } else if (packet is ResponsePacket responsePacket) { OnResponsePacketReceived?.Invoke(responsePacket); m_requestRegistry.HandlePacket(responsePacket); } } catch (Exception e) { msg.SenderConnection.Deny(string.Format("Internal Error: {0}", e.ToString())); } }
private void HandleAuthClient() { //Inicia Thread KeepAlive var keepAliveThread = new Thread(new ThreadStart(KeepAlive)); keepAliveThread.Start(); while (Tcp.Connected) { try { var messageBufferRead = new byte[500000]; //Tamanho do BUFFER á ler //Lê mensagem do cliente var bytesRead = Tcp.GetStream().Read(messageBufferRead, 0, 500000); //variável para armazenar a mensagem recebida var message = new byte[bytesRead]; //Copia mensagem recebida Buffer.BlockCopy(messageBufferRead, 0, message, 0, bytesRead); var json = System.Text.Encoding.Default.GetString(message); var response = JsonConvert.DeserializeObject <AuthPacket>(json); //Dispara evento OnPacketReceived OnPacketReceived?.Invoke(this, response); } catch { OnDisconnect?.Invoke(); } } }
private void RecvThread() { while (Active) { try { var from = new IPEndPoint(0, 0); var recvBuffer = udpClient.Receive(ref from); if (recvBuffer == null || recvBuffer.Length == 0) { continue; } var packet = Packet.FromByteArray(recvBuffer); try { OnPacketReceived?.Invoke(from, packet); } catch (Exception e) { Console.WriteLine(e); } } catch (SocketException) { } catch (Exception e) { Console.WriteLine(e); } } }
// public delegate void OnSceneGraphReceived(byte[] bytes); public void Create(string ip, int port, OnPacketReceived callbackDelegate) { if (running) { return; } socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Connect(ip, port); if (!socket.Connected) { Debug.Log("Connection failed!"); return; } running = true; this.callbackDelegate = callbackDelegate; // Upon connection, the Hyperverse server will pass us the entire scene-graph under the INIT packet. // The client update function will run on a separate thread. thread = new Thread(Run); thread.Start(); }
/// <summary> /// Extract the first incoming packet. /// </summary> public bool ReceivePacket(out Buffer buffer, out IPEndPoint source) { if (Port == 0) { Stop(); throw new InvalidOperationException( "You must specify a non-zero port to UdpProtocol.Start() before you can receive data."); } if (inQueue.Count != 0) { lock (inQueue) { Datagram dg = inQueue.Dequeue(); buffer = dg.buffer; source = dg.ip; #if DEBUG Debug.Log("[UdpProtocol:ReceivePacket(" + buffer.size + ", " + source + ") - Receiving packet ...."); #endif if (OnPacketReceived != null) { OnPacketReceived.Invoke(buffer, source); } return(true); } } buffer = null; source = null; return(false); }
/// <summary> /// Handler for end of the begin receive call. /// </summary> /// <param name="ar">Contains the results of the receive.</param> private void EndReceiveFrom(IAsyncResult ar) { try { // When socket is closed the object will be disposed of in the middle of a receive. if (!m_isClosed) { EndPoint remoteEP = m_addressFamily == AddressFamily.InterNetwork ? new IPEndPoint(IPAddress.Any, 0) : new IPEndPoint(IPAddress.IPv6Any, 0); int bytesRead = m_udpSocket.EndReceiveFrom(ar, ref remoteEP); if (bytesRead > 0) { // During experiments IPPacketInformation wasn't getting set on Linux. Without it the local IP address // cannot be determined when a listener was bound to IPAddress.Any (or IPv6 equivalent). If the caller // is relying on getting the local IP address on Linux then something may fail. //if (packetInfo != null && packetInfo.Address != null) //{ // localEndPoint = new IPEndPoint(packetInfo.Address, localEndPoint.Port); //} byte[] packetBuffer = new byte[bytesRead]; Buffer.BlockCopy(m_recvBuffer, 0, packetBuffer, 0, bytesRead); OnPacketReceived?.Invoke(this, m_localPort, remoteEP as IPEndPoint, packetBuffer); } } } catch (SocketException) { // Socket errors do not trigger a close. The reason being that there are genuine situations that can cause them during // normal RTP operation. For example: // - the RTP connection may start sending before the remote socket starts listening, // - an on hold, transfer, etc. operation can change the RTP end point which could result in socket errors from the old // or new socket during the transition. // It also seems that once a UDP socket pair have exchanged packets and the remote party closes the socket exception will occur // in the BeginReceive method (very handy). Follow-up, this doesn't seem to be the case, the socket exception can occur in // BeginReceive before any packets have been exchanged. This means it's not safe to close if BeginReceive gets an ICMP // error since the remote party may not have initialised their socket yet. //logger.LogWarning($"SocketException UdpReceiver.EndReceiveMessage. {sockExcp}"); } catch (ObjectDisposedException) // Thrown when socket is closed. Can be safely ignored. { } catch (Exception excp) { Logger.Logger.Error($"Exception UdpReceiver.EndReceiveMessage. ->{excp}"); Close(excp.Message); } finally { if (!m_isClosed) { BeginReceiveFrom(); } } }
public virtual void ___recv___(Victem victem, string packet) { var handler = OnPacketReceived; if (handler != null) { OnPacketReceived?.Invoke(victem, packet); } }
/// <summary> /// Manuseia Comunicação do Cliente /// </summary> private void HandleClient(object obj) { try { //Recebe cliente a partir do parâmetro TcpClient tcpClient = (TcpClient)obj; NetworkStream clientStream = tcpClient.GetStream(); #region READ ON CONNECT INICIAL AuthPacket packet = ReceivePacket(clientStream); var client = new AuthClient(tcpClient) { Name = packet.Message.ServerName, Type = packet.Message.ServerType, Key = packet.Message.Key }; Clients.Add(client); ClientConnected(client); OnPacketReceived?.Invoke(client, packet); #endregion //Escuta contínuamente as mensagens dos clientes (Servidores) enquanto estiver conectado while (tcpClient.Connected) { try { packet = ReceivePacket(clientStream); OnPacketReceived?.Invoke(client, packet); } catch (Exception erro) { Console.WriteLine(DateTime.Now.ToString() + $" Exception error:" + Environment.NewLine); Console.WriteLine(erro.Message + Environment.NewLine); //Desconecta client DisconnectClient(client); } } //Caso o Client não estiver mais conectado DisconnectClient(client); } catch (Exception erro) { Console.WriteLine(DateTime.Now.ToString() + $" Exception error:" + Environment.NewLine); Console.WriteLine(erro.Message + Environment.NewLine); } }
private void InvokeDataReceivedEvent(Packet packet) { try { OnPacketReceived?.Invoke(packet.PacketPayload); } catch (Exception exception) { logger?.LogError(exception, "OnPacketReceived threw an exception"); } }
internal void HandlePacket(PosixTimeval timeval, TcpPacket tcp, TcpConnection connection) { OnPacketReceived?.Invoke(timeval, tcp, connection, this); // look for disconnection if (tcp.Finished == true) { IsOpen = false; OnFlowClosed?.Invoke(timeval, tcp, connection, this); } }
private void MonitorStreams() { while (IsRunning) { foreach (var client in Connections.ToList()) { if (!client.IsSocketConnected()) { var e5 = BuildEvent(client, null, String.Empty); Connections.Remove(client); OnConnectionRemoved?.Invoke(this, e5); continue; } if (client.Socket.Available != 0) { var readObject = ReadObject(client.Socket); var e1 = BuildEvent(client, null, readObject); OnPacketReceived?.Invoke(this, e1); if (readObject is PingPacket ping) { client.SendObject(ping).Wait(); continue; } if (readObject is PersonalPacket pp) { var destination = Connections.FirstOrDefault(c => c.ClientId.ToString() == pp.GuidId); var e4 = BuildEvent(client, destination, pp); OnPersonalPacketReceived?.Invoke(this, e4); if (destination != null) { destination.SendObject(pp).Wait(); var e2 = BuildEvent(client, destination, pp); OnPersonalPacketSent?.Invoke(this, e2); } } else { foreach (var c in Connections.ToList()) { c.SendObject(readObject).Wait(); var e3 = BuildEvent(client, c, readObject); OnPacketSent?.Invoke(this, e3); } } } } } }
/// <summary> /// Manuseia Comunicação do Cliente /// </summary> private void HandlePlayer(object obj) { //Recebe cliente a partir do parâmetro TcpClient tcpClient = (TcpClient)obj; var Player = OnConnectPlayer(tcpClient); var thread = new Thread(new ThreadStart(Player.RefreshData)); thread.Start(); //Chama evento OnClientConnected this.OnClientConnected?.Invoke(Player); while (Player.Connected) { try { byte[] message = ReceivePacket(tcpClient.GetStream()); if (message.Length >= 5) { if (Player.Connected) { var packet = new Packet(message, Player.GetKey); if (ShowLog) { packet.Log(); } //Dispara evento OnPacketReceived OnPacketReceived?.Invoke(Player, packet: packet); } } else { if (Player.Connected) { DisconnectPlayer(Player); } } } catch (Exception ex) { ServerExpection(Player, ex); } } if (Player.Connected) { DisconnectPlayer(Player); } }
private async Task Listen() { List <string> removeList = new List <string>(); for (int i = clients.Count - 1; i >= 0; i--) { Client client = clients[i]; if (client.IsAlive()) { Packet p = await client.Listen(); if (p != null) { PacketType type = p.GetPacketType(); if (type == PacketType.Identify) { OnUserConnect.Invoke(this, new UserConnectEventArgs(client)); } else { OnPacketReceived.Invoke(this, new PacketReceivedEventArgs(client, p)); } } } else { await client.Stop(); Logger.Info($"Client dropped [{client.GetSessionId()}]"); clients.RemoveAt(i); string sess = client.GetSessionId(); bool onlyone = true; for (int j = clients.Count - 1; j >= 0; j--) { if (clients[j].GetSessionId() == sess) { onlyone = false; break; } } if (onlyone) { OnUserDisconnect.Invoke(this, new UserDosconnectEventArgs(client)); } } } }
private void RawPacketReceived(byte[] data) { IDataPacket parsedPacket; using (var ms = new MemoryStream(data) { Position = 2 }) { parsedPacket = PacketProcessor.ParsePacket(ms); parsedPacket.DeserializeFrom(ms); } OnPacketReceived.Raise(this, new ClientPacketEventArgs(parsedPacket, this, data.Length)); }
private void RecvThread() { while (Active) { try { var packet = Packet.FromStream(reader); OnPacketReceived?.Invoke(packet); } catch (Exception e) { Console.WriteLine(e); } } }
/// <summary> /// Handler for end of the begin receive call. /// </summary> /// <param name="ar">Contains the results of the receive.</param> private void EndReceiveMessageFrom(IAsyncResult ar) { try { // When socket is closed the object will be disposed of in the middle of a receive. if (!m_isClosed) { SocketFlags flags = SocketFlags.None; EndPoint remoteEP = (m_udpSocket.LocalEndPoint.AddressFamily == AddressFamily.InterNetwork) ? new IPEndPoint(IPAddress.Any, 0) : new IPEndPoint(IPAddress.IPv6Any, 0); int bytesRead = m_udpSocket.EndReceiveMessageFrom(ar, ref flags, ref remoteEP, out var packetInfo); if (bytesRead > 0) { IPEndPoint localEndPoint = new IPEndPoint(packetInfo.Address, (m_udpSocket.LocalEndPoint as IPEndPoint).Port); byte[] packetBuffer = new byte[bytesRead]; Buffer.BlockCopy(m_recvBuffer, 0, packetBuffer, 0, bytesRead); OnPacketReceived?.Invoke(this, localEndPoint, remoteEP as IPEndPoint, packetBuffer); } } } catch (SocketException) { // Socket errors do not trigger a close. The reason being that there are genuine situations that can cause them during // normal RTP operation. For example: // - the RTP connection may start sending before the remote socket starts listening, // - an on hold, transfer, etc. operation can change the RTP end point which could result in socket errors from the old // or new socket during the transition. // It also seems that once a UDP socket pair have exchanged packets and the remote party closes the socket exception will occur // in the BeginReceive method (very handy). Follow-up, this doesn't seem to be the case, the socket exception can occur in // BeginReceive before any packets have been exchanged. This means it's not safe to close if BeginReceive gets an ICMP // error since the remote party may not have initialised their socket yet. } catch (ObjectDisposedException) // Thrown when socket is closed. Can be safely ignored. { } catch (Exception excp) { logger.LogError($"Exception UdpReceiver.EndReceiveMessageFrom. {excp}"); Close(excp.Message); } finally { if (!m_isClosed) { BeginReceive(); } } }
private void RawPacketReceived(object sender, RawServerPacketEventArgs e) { IDataPacket parsedPacket; var rawDat = e.RawData; rawDat = PacketProcessor.ProcessRawData(rawDat); using (var ms = new MemoryStream(rawDat) { Position = 2 }) { parsedPacket = PacketProcessor.ParsePacket(ms); parsedPacket.DeserializeFrom(ms); } OnPacketReceived.Raise(this, new ServerPacketEventArgs(parsedPacket, e.Peer, this, e.RawData.Length)); }
public void StartNewRtSession(RtSessionInfo info, OnPlayerConnectedToGame onPlayerConnectedToGame, OnPlayerDisconnected onPlayerDisconnected, OnRTReady onRtReady, OnPacketReceived onPacketReceived) { GameSparksController.Instance().GetGameSparksFactory().StartNewRtSession( info, onPlayerConnectedToGame, onPlayerDisconnected, onRtReady, onPacketReceived, ref _sessionInfo, ref _gameSparksRtUnity ); }
private void OnDataReceived(IAsyncResult res) { IPEndPoint ip = new IPEndPoint(IPAddress.Any, ReceivePort); byte[] data = client.EndReceive(res, ref ip); UdpPacket packet = UdpPacket.ParseData(data); if (packet != null) { OnPacketReceived?.Invoke(packet); } else { Console.Out.WriteLine("Bad packet received."); } client.BeginReceive(new AsyncCallback(OnDataReceived), null); }
private void ReceiveLoop() { while (_alive) { int bytesRec = _socket.Receive(_buffer); if (_currentPacket == null) { _currentPacket = new Packet(); } if (_currentPacket.AddFragment(_buffer, bytesRec)) { OnPacketReceived?.Invoke((Packet)_currentPacket.Clone()); _currentPacket = null; } } }
/// <summary> /// Manuseia Comunicação do Cliente /// </summary> private void HandlePlayer(object obj) { //Recebe cliente a partir do parâmetro TcpClient tcpClient = (TcpClient)obj; var Player = OnConnectPlayer(tcpClient); //Chama evento OnClientConnected this.OnClientConnected?.Invoke(Player); while (Player.Connected) { try { byte[] message = ReceivePacket(tcpClient.GetStream()); if (message.Length >= 5) { if (Player.Connected) { Player.Server = this; //Dispara evento OnPacketReceived OnPacketReceived?.Invoke(Player, packet: new Packet(message, Player.GetKey)); } } else { if (Player.Connected) { DisconnectPlayer(Player); } } } catch { DisconnectPlayer(Player); } } if (Player.Connected) { DisconnectPlayer(Player); } }
/// <summary> /// Manuseia Comunicação do Cliente /// </summary> private void HandleClient(object obj) { //Recebe cliente a partir do parâmetro TcpClient tcpClient = (TcpClient)obj; NetworkStream clientStream = tcpClient.GetStream(); #region READ ON CONNECT INICIAL AuthPacket packet = ReceivePacket(clientStream); var client = new AuthClient(tcpClient, packet); Clients.Add(client); Console.Title = string.Format("Pangya Fresh Up! AuthServer - LOGIN: {0}, GAMES: {1}, MESSENGER: {2}", Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.LoginServer).ToList().Count, Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.GameServer).ToList().Count, Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.MessengerServer).ToList().Count); ClientConnected(client); OnPacketReceived?.Invoke(client, packet); #endregion //Escuta contínuamente as mensagens dos clientes (Servidores) enquanto estiver conectado while (tcpClient.Connected) { try { packet = ReceivePacket(clientStream); OnPacketReceived?.Invoke(client, packet); } catch { //Desconecta client DisconnectClient(client); } } //Caso o Client não estiver mais conectado if (tcpClient.Connected) { DisconnectClient(client); } }
protected async Task Init() { // Get Info serverInfo = await rpc.ServerInfoAsync(new ServerInfoRequest()); // TCP relay tcpRelaySocket.OnPacketReceived += (buf, len) => { OnPacketReceived?.Invoke(buf, len); }; tcpRelaySocket.Init(); // Periodically restart listeners & reconnect PingTimer = new Timer(); PingTimer.Interval = 15000; PingTimer.Elapsed += PingServer; PingTimer.Start(); // Sync clients periodically Task.Run(SyncTask); }
private void HandlePacket(object obj) { //Recebe OnCliente a partir do parâmetro TcpClient tcpClient = (TcpClient)obj; var Player = OnConnectBot(tcpClient); //Chama evento OnClientConnected this.OnClientConnected?.Invoke(Player); while (Player.Tcp.Connected) { try { var messageBufferRead = new byte[500000]; //Tamanho do BUFFER á ler //Lê mensagem do OnCliente //size =500000; int bytesRead = Player.Tcp.GetStream().Read(messageBufferRead, 0, 500000); //variável para armazenar a mensagem recebida byte[] message = new byte[bytesRead]; //Copia mensagem recebida Buffer.BlockCopy(messageBufferRead, 0, message, 0, bytesRead); if (message.Length >= 5) { var packet = new ClientPacket(message); OnPacketReceived?.Invoke(Player, packet); } } catch (Exception ex) { OnException(Player, ex); } } }
public void OnTcpReceived(IDoubleServerClient client, BitBuffer buffer) { if (buffer.TotalBitsLeft < 8) { return; } byte packet = buffer.ReadByte(); if (packet >= TcpHandlers.Length) { return; } byte[] bytes = buffer.ReadBytes(); NetworkServerClient serverClient = (NetworkServerClient)client.ExtraData; // ReSharper disable once ConvertToLocalFunction Action handler = () => { if (_server != null) { OnPacketReceived action = TcpHandlers[packet]; if (action != null) { _handlerBuffer.SetContents(bytes); action((NetworkServerClient)client.ExtraData, _handlerBuffer); } } }; if (!NetworkUtils.SimulateNetworkConditions || NetworkUtils.IsLocal(serverClient.Id)) { UnityFixedDispatcher.InvokeNoDelay(handler); } else { UnityFixedDispatcher.InvokeDelayed(NetworkUtils.SimulatedNetDelay, handler); } }
public void Connect(IPEndPoint endPoint) { _peer.Start(); _listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) => { var dataPacket = new DataPacket(dataReader.RawData, dataReader.UserDataOffset, dataReader.UserDataSize, ConvertDeliveryMethod(deliveryMethod)); OnPacketReceived?.Invoke(endPoint, dataPacket, dataReader.Recycle); }; _listener.PeerConnectedEvent += peer => { _serverPeer = peer; OnConnected?.Invoke(peer.EndPoint); }; _listener.PeerDisconnectedEvent += (peer, info) => { _serverPeer = null; using (var disconnectInfo = new LiteNetDisconnectInfo(info)) OnDisconnected?.Invoke(endPoint, disconnectInfo); }; _peer.Connect(endPoint.Address.ToString(), endPoint.Port, "SomeConnectionKey333"); }
IEnumerator StartReading() { byte[] meta = new byte[sizeof(Int32)]; while (!cts.IsCancellationRequested) { while (!cts.IsCancellationRequested && stream.DataAvailable) { var bytesRead = stream.Read(meta, 0, meta.Length); if (bytesRead > 0) { var packetSize = BitConverter.ToInt32(meta, 0); byte[] data = new byte[packetSize]; var startIndex = 0; while (startIndex < packetSize && !cts.IsCancellationRequested) { bytesRead = stream.Read(data, startIndex, packetSize - startIndex); startIndex += bytesRead; } OnPacketReceived?.Invoke(System.Text.Encoding.ASCII.GetString(data)); } } yield return(new WaitForEndOfFrame()); } }
private void RecvThread() { byte[] recvBuf = new byte[4096]; while (connected) { // Read the udp pak header .. int read = 0; while (read < 2) { read += socket.Receive(recvBuf, read, 2, SocketFlags.None); } ushort pakSize = (ushort)((recvBuf[0] << 8) | recvBuf[1]); // << content size pakSize += RECV_HDR_SIZE; // Read the full packet while (read < pakSize) { read += socket.Receive(recvBuf, read, pakSize - read, SocketFlags.None); } // Handle packet OnPacketReceived?.Invoke(recvBuf, pakSize); } }