private void ListenLoop() { try { while (OscReceiver.State != OscSocketState.Closed) { // if we are in a state to receive if (OscReceiver.State != OscSocketState.Connected) { continue; } // get the next message // this will block until one arrives or the socket is closed OscPacket packet = OscReceiver.Receive(); PacketReceived?.Invoke(packet); if (packet.Error == OscPacketError.None) { OscAddressManager.Invoke(packet); } PacketProcessed?.Invoke(packet); } } catch (Exception ex) { } }
private void _processClientPackets() { if (_isClosing || !_doPacketProcess) { return; } _localRecvPackets = _localSecurity.TransferIncoming(); if (_localRecvPackets != null) { foreach (var packet in _localRecvPackets) { if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001) { continue; } //Send to PacketHandler PacketReceived?.Invoke(packet); } } _localSendBuffers = _localSecurity.TransferOutgoing(); if (_localSendBuffers == null) { return; } foreach (var buffer in _localSendBuffers) { PacketSend?.Invoke(buffer.Value); Send(buffer.Key.Buffer); } }
private void OnReceiveData(IAsyncResult ar) { if (IsConnected) { try { if (_socket.Poll(0, SelectMode.SelectRead) && _socket.Available <= 0) { Disconnect(true); } else { byte[] data = _buffer; if (_encryption != null) { data = _encryption.Decrypt(data); } PacketReceived?.Invoke(this, PBEPacketProcessor.CreatePacket(Battle, data)); BeginReceive(); } } catch (Exception ex) { NotifyError(ex); Disconnect(true); } } }
public bool TryReceive() { // if we are in a state to receive if (OscReceiver?.State != OscSocketState.Connected) { return(false); } // try and get the next message bool packetReceived = OscReceiver.TryReceive(out OscPacket packet); if (packetReceived == false) { return(false); } PacketReceived?.Invoke(packet); if (packet?.Error == OscPacketError.None) { OscAddressManager.Invoke(packet); } PacketProcessed?.Invoke(packet); return(true); }
/// <summary> /// Async callback when a packet is received /// </summary> /// <param name="result"></param> private void OnPacketReceived(IAsyncResult result) { try { // Recalls the state var _state = result.AsyncState as StateObject; // Grabs the numbber of bytes received and ends the receive var bytes = _state.Socket.EndReceiveFrom(result, ref _state.RemoteEndpoint); // Creates a temp byte array to put the received data var packetData = new byte[bytes]; // Coppies the buffer passed in the stateobject to the temp byte array instantiated above Array.Copy(_state.Buffer, 0, packetData, 0, packetData.Length); // Fires the packet received event for Tcp.cs to handle PacketReceived?.Invoke(new Packet(packetData)); // Restarts the async receive loop _state.Socket.BeginReceiveFrom(_state.Buffer, 0, _state.Buffer.Length, SocketFlags.None, ref _state.RemoteEndpoint, OnPacketReceived, new StateObject(_state.RemoteEndpoint, _state.Buffer, _state.Socket)); } catch (Exception ex) { UdpError?.Invoke(ex); } }
public void ReceivePacket(int toReceive) { try { int len = networkStream.Read(receiveBuffer, 0, Math.Min(toReceive, receiveBuffer.Length)); if (len <= 0) { Close(); return; } toReceive -= len; ms.Write(receiveBuffer, 0, len); if (toReceive > 0) { ReceivePacket(toReceive); return; } ms.Position = 0L; PacketReceived?.Invoke(this, new PacketReceivedEventArgs(new BinaryReader(ms))); ms.Close(); } catch (SocketException) { Close(); } catch (Exception) { /*Don't handle*/ } networkStream.BeginRead(lenBuffer, 0, lenBuffer.Length, Receive, null); }
public void ReceiveCallback(IAsyncResult ar) { var endpoint = new IPEndPoint(MulticastAddress, Port); try { var receiveBytes = Client?.EndReceive(ar, ref endpoint); PacketReceived?.Invoke(this, receiveBytes); } catch (ObjectDisposedException) { if (isQuitting) { return; } } catch (Exception e) { Console.WriteLine(e); throw; } Console.WriteLine($"Endpoint: {endpoint}"); Client?.BeginReceive(ReceiveCallback, null); }
private async void ListenForPackets(CancellationToken token) { try { while (!token.IsCancellationRequested) { while (!token.IsCancellationRequested && Available == 0) { await Task.Delay(10); } while (!token.IsCancellationRequested && Available > 0) { IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0); var data = Receive(ref endPoint); PacketReceived?.Invoke(this, new PacketReceivedArgs(data)); } } } catch (Exception e) { var ex = e; while (ex != null) { Console.WriteLine($"TempestExceptions:{ex.GetType()}:{ex.Message}:{ex.StackTrace}"); ex = ex.InnerException; } } }
private void OnReceive(string data) { if (String.IsNullOrEmpty(data)) { return; } DataReceived?.Invoke(this, new AprsDataReceivedEventArgs(data)); if (PacketReceived == null) { return; } AprsMessage packetInfo; try { packetInfo = PacketInfo.Parse(data); } catch (Exception ex) { Trace.TraceInformation(ex.ToString()); return; } // Usually the case when the packet is corrupt or something like that. if (packetInfo == null) { return; } PacketReceived.Invoke(this, new PacketReceivedEventArgs(packetInfo)); }
private void ReceivePendingPackets() { bool hasReceived; do { byte[] packet = null; lock (_pendingPackets) { if (_pendingPackets.Count > 0) { packet = _pendingPackets.Dequeue(); } } hasReceived = false; if (packet != null) { hasReceived = true; using (MemoryStream stream = new MemoryStream(packet, false)) { using (BinaryReader reader = new BinaryReader(stream)) { PacketReceived?.Invoke(reader); } } } }while (hasReceived); }
private void ThreadFunc() { Count = 0; try { Client = new UdpClient(Port); } catch (Exception e) { MessageBox.Show(e.ToString(), nameof(UdpCli), MessageBoxButton.OK, MessageBoxImage.Error); } try { while (Running) { IPEndPoint ep = null; byte[] bts = Client.Receive(ref ep); DateTime now = DateTime.Now; string data = Encoding.UTF8.GetString(bts); PacketReceived?.Invoke(now, Count, data); Count++; } } catch (ThreadAbortException) { } catch (SocketException) { } catch (Exception e) { MessageBox.Show(e.ToString(), nameof(UdpCli), MessageBoxButton.OK, MessageBoxImage.Error); } finally { Client?.Dispose(); } }
protected void Receive() { try { byte[] buffer = new byte[DataBufferSize]; client.GetStream().BeginRead(buffer, 0, buffer.Length, (result) => { try { int byteLength = client.GetStream().EndRead(result); Receive(); byte[] buffer = (byte[])result.AsyncState; PacketReceived?.Invoke(this, new Packet { Bytes = buffer.Take(byteLength).ToArray() }); } catch (Exception e) { Dispose(); Disconnected?.Invoke(this, new DisconnectedEventArgs(e, 0)); } }, buffer); } catch (Exception e) { Dispose(); Disconnected?.Invoke(this, new DisconnectedEventArgs(e, 0)); } }
protected override void OnPacketsReceived(object[] packets) { foreach (var item in packets) { PacketReceived?.Invoke(this, new PacketReceivedEventArgs(item)); } }
public async void BeginReadData() { try { int bytesread = await _stream.ReadAsync(_buffer, 0, BUFFERSIZE); while (bytesread > 0) { int offset = 0; do { var packet = _decoder.GetFromBytes(_buffer, ref offset); if (packet != null) { PacketReceived?.Invoke(packet); } else if (offset < bytesread) { _dataoffset = bytesread - offset; Array.Copy(_buffer, offset, _buffer, 0, _dataoffset); break; } } while (offset < bytesread); bytesread = await _stream.ReadAsync(_buffer, _dataoffset, BUFFERSIZE - _dataoffset); } } catch { Console.WriteLine("Client Read Aborted"); } Console.WriteLine("DONE"); }
private void ProcessReceive(UdpPacket packet) { if (IsDisposed) { packet.Return(); return; } ReceivePacket(); try { if (packet.EndReceive()) { try { PacketReceived?.Invoke(this, packet); } catch { // What now? } } else { // Ignore bad receive } } finally { packet.Return(); } }
/// <summary> /// Extracts packets from the DataBuffer /// </summary> private void ProcessRawData(int received) { int total = received + BufferOffset; int offset = 0; if (!Handshaken) { offset += ParseHandshake(); } while (total - offset > RegularHeaderLength) { int length = GetPacketLength(DataBuffer, offset); if ((total - offset) < length) { byte[] leftover = new ArraySegment <byte>(DataBuffer, offset, (total - offset)).ToArray(); Buffer.BlockCopy(leftover, 0, DataBuffer, 0, leftover.Length); BufferOffset = leftover.Length; return; } offset += RegularHeaderLength; byte[] packetData = new ArraySegment <byte>(DataBuffer, offset, length).ToArray(); RemoteCipher.Decrypt(ref packetData); offset += length; PacketReceived?.Invoke(new PacketReader(ref packetData, IncomingPacketType.DynamicHeader)); } }
private void SpPollTimer_Tick(object sender, System.Timers.ElapsedEventArgs e) { if (inSpPoll) { return; } inSpPoll = true; if (Channel == null) { inSpPoll = false; return; } while (Channel != null && ReceiveEnabled) { if (!Channel.IsOpen) { break; } int toRead = 0; try { toRead = Channel.BytesToRead; } catch { disconnectSP(); inSpPoll = false; return; } if (toRead >= 3) { var com = new PacketCommandMini(); var resp = ProtocolError.Unknown; try { resp = PacketCommandMini.FromStream(ref com, Channel, 10, flushTB); } catch (Exception ex) { disconnectSP(); inSpPoll = false; return; } Application.DoEvents(); if (resp == ProtocolError.None) { bool bkp = ReceiveEnabled; ReceiveEnabled = false; PacketReceived?.Invoke(com); ReceiveEnabled = bkp; } } else { break; } } inSpPoll = false; }
private void ReadCallback(IAsyncResult ar) { try { ClientPlayer player = (ClientPlayer)ar.AsyncState; Socket client = player.socket; // Read data from the remote device. int bytesRead = client.EndReceive(ar); if (bytesRead > 0) { var currentBytes = new byte[bytesRead]; Buffer.BlockCopy(player.buffer, 0, currentBytes, 0, bytesRead); player.accumulatedBytes.AddRange(currentBytes); if (player.accumulatedBytes.Count >= Packet.packetHeaderSize) { //If we're not at the start of a packet, increment our position until we are, or we run out of bytes var accumulatedBytes = player.accumulatedBytes.ToArray(); while (accumulatedBytes.Length >= Packet.packetHeaderSize && !Packet.StreamIsAtPacket(accumulatedBytes)) { player.accumulatedBytes.RemoveAt(0); accumulatedBytes = player.accumulatedBytes.ToArray(); } while (accumulatedBytes.Length >= Packet.packetHeaderSize && Packet.PotentiallyValidPacket(accumulatedBytes)) { Packet readPacket = null; try { readPacket = Packet.FromBytes(accumulatedBytes); PacketReceived?.Invoke(readPacket); } catch (Exception e) { Console.WriteLine(e); } //Remove the bytes which we've already used from the accumulated List //If the packet failed to parse, skip the header so that the rest of the packet is consumed by the above vailidity check on the next run player.accumulatedBytes.RemoveRange(0, readPacket?.Size ?? Packet.packetHeaderSize); accumulatedBytes = player.accumulatedBytes.ToArray(); } } // Get the rest of the data. client.BeginReceive(player.buffer, 0, ClientPlayer.BufferSize, 0, new AsyncCallback(ReadCallback), player); } } catch (ObjectDisposedException) { ServerDisconnected_Internal(); } catch (Exception e) { Logger.Debug(e.ToString()); ServerDisconnected_Internal(); } }
private void ReceivePayloadStreamCallback(IAsyncResult ar) { try { //Attempt to finish the async read. var read = socket.EndReceive(ar); //Same as above if (read <= 0) { throw new SocketException((int)SocketError.ConnectionAborted); } CheckFlood(); //Subtract what we read from the payload size. dataExpected -= read; //Write the data to the payload stream. payloadStream.Write(buffer, 0, read); ReceiveProgressChanged?.Invoke(this, (int)payloadStream.Length, dataExpected); //Update global how many bytes we have received. TotalBytesReceived += read; //If there is more data to receive, keep the loop going. if (dataExpected > 0) { //See how much data we need to receive like the initial receive. int receiveSize = dataExpected > ClientOptions.BufferSize ? ClientOptions.BufferSize : dataExpected; socket.BeginReceive(buffer, 0, receiveSize, 0, ReceivePayloadStreamCallback, null); //If we received everything } else { //Close the payload stream payloadStream.Close(); //Get the full payload byte[] payload = payloadStream.ToArray(); //Dispose the stream payloadStream = null; //Start receiving size header again BeginReceive(); //Call the event method PacketReceived?.Invoke(this, new PacketReceivedEventArgs(payload)); } } catch (NullReferenceException) { return; } catch (ObjectDisposedException) { return; } catch (Exception ex) { HandleDisconnect(ex); } }
private void FireMessageReceivedEvent(Message message) { PacketReceivedEventArgs args = new PacketReceivedEventArgs { Message = message }; PacketReceived?.Invoke(this, args); }
private IOperation ReceiveSetup() { IOperation operation = new ReceiveOperation(); operation.PacketReceived += (s, e) => PacketReceived?.Invoke(this, e); _context.Data = new List <byte>(); return(operation); }
protected virtual void OnPacketReceived(byte[] incomingPacket, CSteamID remoteId) { PacketReceived?.Invoke(this, new PacketReceiveArgs() { Packet = incomingPacket, RemoteId = remoteId }); }
public void StartListening() { StopListening(); this.Client = new UdpClient(Port); Task.Run(async() => { var endpoint = new IPEndPoint(IPAddress.Any, Port); try { //TODO: this is an initial version, i feel like this can be done more elegant? (atleast async, not thread blocking like now) while (true) { try { var result = await Client.ReceiveAsync(); var bytes = result.Buffer; var message = OscPacket.GetPacket(bytes) as OscMessage; var musePacket = ParsePacket(message); if (musePacket.Address == SignalAddress.Unknown) { Console.WriteLine($"unknown packet with address '{message.Address}', skipping it..."); continue; } PacketReceived?.Invoke(this, musePacket); } catch (ObjectDisposedException) { Console.WriteLine("disposed early"); throw; } catch (Exception ex) { Console.WriteLine($"Corrupt packet received: '{ex.Message}'"); } } } catch (ObjectDisposedException) { //is fine, atm this is the escape condition when the listener needs to stop listening to the port. far from elegant but it works i suppose :) Console.WriteLine("exited"); } catch (SocketException e) { Console.WriteLine(e); } catch (Exception ex) { Console.WriteLine("something else threw an exception... " + ex.Message); } finally { this.Client?.Dispose(); this.Client = null; } }); }
internal override byte[] ReadPacket() { var buffer = new List <byte>(); buffer.Add((byte)_stream.ReadByte()); var identifier = buffer[0]; switch (identifier) { case 0x26: buffer.AddRange(ReadBytes(11)); buffer.AddRange(GetChatPacket(buffer)); break; case 0x5b: buffer.AddRange(ReadBytes(2)); buffer.AddRange(ReadBytes(BitConverter.ToInt16(buffer.ToArray(), 1) - 3)); break; case 0x94: buffer.AddRange(ReadBytes(1)); buffer.AddRange(ReadBytes((buffer[1] * 3) + 4)); break; case 0xa8: case 0xaa: buffer.AddRange(ReadBytes(6)); buffer.AddRange(ReadBytes(buffer[6] - 7)); break; case 0xac: buffer.AddRange(ReadBytes(12)); buffer.AddRange(ReadBytes(buffer[12] - 13)); break; case 0xae: buffer.AddRange(ReadBytes(2)); buffer.AddRange(ReadBytes(BitConverter.ToInt16(buffer.ToArray(), 1))); break; case 0x9c: case 0x9d: buffer.AddRange(ReadBytes(2)); buffer.AddRange(ReadBytes(buffer[2] - 3)); break; default: if (identifier >= PacketSizes.Length) { throw new D2GSPacketException("Unable to determine packet size"); } buffer.AddRange(ReadBytes(PacketSizes[identifier] - 1)); break; } PacketReceived?.Invoke(this, new D2gsPacket(buffer)); return(buffer.ToArray()); }
public static void Start() { int length = _recorder.Packets.Count; for (int i = 0; i < length; i++) { PacketReceived?.Invoke(_recorder.Packets[i]); } }
internal void GatherPendingData(IAsyncResult result) { try { // Keep reading data into the small buffer and then moving it into the big buffer var bytesReceived = 0; if (Socket != null) { bytesReceived = Socket.EndReceive(result); if (bytesReceived > 0) { for (var i = 0; i < bytesReceived; i++) { largeBuffer.Add(smallBuffer[i]); } } } // Handle the case where there is no data, a special case for connected sockets that are disconnecting if (bytesReceived == 0) { return; } // Do we have a complete packet available? if (largeBuffer.Count > 0) { var packet = (Packet)null; do { packet = DecodeBuffer(); if (packet != null) { PacketReceived?.Invoke(packet); } }while (packet != null); } // Ask for additional data if the last packet wasn't a disconnection that set Socket to null if (Socket != null) { Socket.BeginReceive(smallBuffer, 0, BufferSize, 0, GatherPendingData, null); } } catch (ObjectDisposedException) { // "Standard practise", Microsoft says, for when the application is closing and the socket is closed return; } catch (Exception ex) { // When errors occur, we must disconnect the client for stability reasons Disconnect(4000, ex.Message); var disconnectionPacket = new Packet(RemoteEndPoint, WebSocketAction.Disconnect, ex.Message); PacketReceived?.Invoke(disconnectionPacket); } }
protected virtual void OnBinaryPacketReceived(IPacket packet, int transferred) { try { PacketReceived?.Invoke(this, new PacketEventArgs(packet, WebSocketMessageType.Binary, transferred)); } catch (Exception ex) { OnException(ex); } }
#pragma warning disable CS1998 // 异步方法缺少 "await" 运算符,将以同步方式运行 private async Task ReadWorker_DoWork(CancellationToken token) #pragma warning restore CS1998 // 异步方法缺少 "await" 运算符,将以同步方式运行 { Action cleanup = () => { _client?.Dispose(); _client = null; }; token.Register(cleanup); while (!token.IsCancellationRequested && _client.Client != null) { Packet packet = null; try { packet = ReadPacket(); } catch (SocketException se) { //如果是网络异常,退出。 #if DEBUG //Env1.Instance.ShowMessage($"desc={se.Message}\nStack={se.StackTrace}"); #endif //如果在事件句柄里面DisposeTcpChannel,它会wait这个循环结束。而这里又在等待这个事件句柄执行完毕,所以就死锁了。 #pragma warning disable 4014 Task.Run(() => { ErrorHappened?.Invoke(ErrorType.SocketError); }, token); #pragma warning restore 4014 break; } catch (Exception ex) { Env.ShowMessage($"desc={ex.Message}\nStack={ex.StackTrace}"); } if (packet != null) { try { //Env.Logger.Log($"Packet received {packet}"); PacketReceived?.Invoke(packet); } catch (Exception e) { #if DEBUG Env.ShowMessage("逻辑层处理消息异常。请检查\n" + e.Message + "\n" + e.StackTrace); #else Env.Logger.Log(e.StackTrace); #endif } } } //end while cleanup(); Env.Logger.Log("ReceiveMessage: Receiving thread end..."); }
private void StartListening() { Logger.Debug("Starting with listening"); try { var buffer = new byte[RxBufferSize]; var bufferOffset = 0; while (tcpClient?.Connected ?? false) { if (tcpClient?.Available > 0) { var read = stream.Read(buffer, bufferOffset, buffer.Length - bufferOffset); var packetCollection = packetsFactory.GetPackets(buffer, 0, read + bufferOffset); foreach (var packet in packetCollection) { Logger.Debug("Received packet from server: {packet}", packet); PacketReceived?.Invoke(this, packet); } var leftover = read + bufferOffset - packetCollection.BytesUsed; if (leftover > 0) { Array.Copy(buffer, packetCollection.BytesUsed, buffer, 0, leftover); bufferOffset = leftover; } else { bufferOffset = 0; } } else { Thread.Sleep(TimeSpan.FromTicks(100)); } } stream = null; if (tcpClient != null && tcpClient.Connected) { tcpClient.Close(); } Disconnected?.Invoke(this, EventArgs.Empty); } catch (Exception ex) { Logger.Error("Got an exceptions while listening to the server"); Logger.Error(ex); Logger.Warn("Disconnecting"); stream?.Close(); stream = null; if (tcpClient != null && tcpClient.Connected) { tcpClient.Close(); Disconnected?.Invoke(this, EventArgs.Empty); } } }
protected override void ProcessPacket(RailPacketIncoming packetBase, Tick localTick) { base.ProcessPacket(packetBase, localTick); RailPacketFromClient clientPacket = (RailPacketFromClient)packetBase; Scope.IntegrateAcked(clientPacket.View); PacketReceived?.Invoke(this, clientPacket); }
public void RegisterHandler(PacketReceived handler) { _masterLayer.AddHandler(handler); }
public void AddHandler(PacketReceived handler) { _service.UdpPacketReceived += handler; }
public void RegisterMatchLobbyHandler(PacketReceived handler) { _layer.AddHandler(handler); }