void UDPMulticastMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments) { try { uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength; string message = eventArguments.GetDataReader().ReadString(stringLength); ParseMessage(message); } catch (Exception exception) { SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult); if (socketError == SocketErrorStatus.ConnectionResetByPeer) { } else if (socketError != SocketErrorStatus.Unknown) { } else { throw; } } }
private async void Multicast_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { handlingPacket = true; var reader = args.GetDataReader(); // check to see if the received data matches the expected message uint length = reader.UnconsumedBufferLength; OneWireEventSource.Log.Debug("DEBUG: packet.length=" + length); OneWireEventSource.Log.Debug("DEBUG: expecting=" + expectedMessage.Length); try { if (length == expectedMessage.Length) { bool dataMatch = true; for (int i = 0; dataMatch && i < length; i++) { dataMatch = (expectedMessage[i] == reader.ReadByte()); } // check to see if we received the expected message if (dataMatch) { OneWireEventSource.Log.Debug("DEBUG: packet match, replying"); // send return message using (var writer = new DataWriter(socket.OutputStream)) { writer.WriteBytes(returnMessage); await writer.StoreAsync(); // we return before the packet goes out, that's fine } } } else { OneWireEventSource.Log.Critical("Unknown packet length recieved: " + length); } } catch (System.IO.IOException) { // drain ; } finally { handlingPacket = false; waitPacketDone.Set(); } }
async void UDPMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments) { try { uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength; string message = eventArguments.GetDataReader().ReadString(stringLength); await ParseMessage(message); } catch (Exception exception) { SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult); if (socketError == SocketErrorStatus.ConnectionResetByPeer) { } else if (socketError != SocketErrorStatus.Unknown) { } else { System.Diagnostics.Debug.WriteLine("Exception while receiving UDP packet:" + exception.Message); } } }
/// <summary> /// Event consumer for udp message received. Raises OSCPacketReceivedEvent. /// </summary> public void udpClient_MessageReceived(object sender, DatagramSocketMessageReceivedEventArgs e) { DataReader reader = e.GetDataReader(); if (reader.UnconsumedBufferLength > 0) { byte[] bytes = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(bytes); OSCPacketReceivedEventArgs args = new OSCPacketReceivedEventArgs(); args.packet = OSCPacket.Unpack(bytes); OnOSCPacketReceivedEvent(args); Debug.WriteLine(args.packet.ToString()); } }
private async void _socketUdp_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { uint stringLength = args.GetDataReader().UnconsumedBufferLength; string receivedMessage = args.GetDataReader().ReadString(stringLength); if (receivedMessage.ToLower().Equals(CommunicationCommands.MCCConnection.ToLower())) { IOutputStream outputStream = await _socketUdp.GetOutputStreamAsync( args.RemoteAddress, args.RemotePort); MCCConnection = new ConnectionInfo(args.RemoteAddress.ToString(), args.RemotePort, outputStream); } MessageReceived?.Invoke(this, new CommunicationMsg(receivedMessage)); } catch (Exception ex) { string error = ex.Message; } }
void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments) { try { // Interpret the incoming datagram's entire contents as a string. uint stringLength = eventArguments.GetDataReader().UnconsumedBufferLength; string receivedMessage = eventArguments.GetDataReader().ReadString(stringLength); NotifyUserFromAsyncThread( "Received data from remote peer: \"" + receivedMessage + "\"", NotifyType.StatusMessage); } catch (Exception exception) { SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult); if (socketError == SocketErrorStatus.ConnectionResetByPeer) { // This error would indicate that a previous send operation resulted in an // ICMP "Port Unreachable" message. NotifyUserFromAsyncThread( "Peer does not listen on the specific port. Please make sure that you run step 1 first " + "or you have a server properly working on a remote server.", NotifyType.ErrorMessage); } else if (socketError != SocketErrorStatus.Unknown) { NotifyUserFromAsyncThread( "Error happened when receiving a datagram: " + socketError.ToString(), NotifyType.ErrorMessage); } else { throw; } } }
private async void _socket_OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs e) { var reader = e.GetDataReader(); string message = reader.ReadString(reader.UnconsumedBufferLength); Logger.Trace("Message from {0}:{1}:\n{2}", e.RemoteAddress.RawName, e.RemotePort, message); IOutputStream outputStream = await sender.GetOutputStreamAsync(e.RemoteAddress, e.RemotePort); Received(this, new PeerCommandEventArgs { Data = message, Peer = new RemotePeer(_serializer, this, outputStream, e.RemoteAddress, e.RemotePort), }); }
private async void UdpListener_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { Log(ServerOptions.Verbosity.Verbose, $"SERVER: UDP: Got incoming message"); Stats.IncrementNConnections(); var dr = args.GetDataReader(); var remoteHost = args.RemoteAddress; var remotePort = args.RemotePort; var os = await sender.GetOutputStreamAsync(remoteHost, remotePort); //var dw = new DataWriter(sender.OutputStream); var dw = new DataWriter(os); Task t = EchoUdpAsync("UDP", dr, dw); await t; }
private void ClientOnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var dataReader = args.GetDataReader(); var endpoint = new IPEndPoint(IPAddress.Parse(args.RemoteAddress.RawName), int.Parse(args.RemotePort)); var buffer = new byte[dataReader.UnconsumedBufferLength]; dataReader.ReadBytes(buffer); OnMessageReceived(buffer, endpoint); } catch { // ignored } }
private void OnDatagramSocketMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { Log("Datagram message received"); if (args == null) { return; } string data; using (var reader = args.GetDataReader()) { data = reader.ReadString(reader.UnconsumedBufferLength); } Log(data); Task task = GetDeviceDescriptionAsync(data, args.LocalAddress); }
private static void UdpClient_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { using (var reader = args.GetDataReader()) { reader.ByteOrder = ByteOrder.LittleEndian; type = reader.ReadInt64(); userID = reader.ReadInt64(); challenge = new byte[16]; reader.ReadBytes(challenge); var padding = new byte[32]; reader.ReadBytes(padding); sender.Dispose(); udpClient = null; waiter.Set(); } }
private void OnSocketMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { using (var reader = args.GetDataReader()) { byte[] response = new byte[48]; reader.ReadBytes(response); _resultCompletionSource.TrySetResult(ParseNetworkTime(response)); } } catch (Exception ex) { _resultCompletionSource.TrySetException(ex); } }
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { DataReader networkDataReader = args.GetDataReader(); int len = networkDataReader.ReadInt32(); byte[] data = new byte[len]; networkDataReader.ReadBytes(data); NetInMessage message = new NetInMessage(data); lock (lockObj) { m_incomingMessageQueue.Enqueue(message); } }
private void HandleIncomingMessages(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs e) { //(await e.RemoteAddress.IPInformation.NetworkAdapter.GetConnectedProfileAsync()).GetNetworkNames(); if (hostNames != null && hostNames.Contains(e.RemoteAddress.ToString())) { return; } var remote = e.RemoteAddress; var local = e.LocalAddress; var reader = e.GetDataReader(); byte[] data = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(data); var msg = ParseMessage(data); if (msg.Type == MessageType.DeviceStateService) { ProcessDeviceDiscoveryMessage(e.RemoteAddress, e.RemotePort, msg); } else { if (taskCompletions.ContainsKey(msg.Source)) { var tcs = taskCompletions[msg.Source]; tcs(msg); } //else if (msg.Type.ToString().StartsWith("State")) //{ //} //else if (msg.Type == MessageType.DeviceAcknowledgement) //{ // if (taskCompletions.ContainsKey(msg.Source)) // { // var tcs = taskCompletions[msg.Source]; // if (!tcs.Task.IsCompleted) // tcs.SetResult(msg); // } //} else { //TODO } } System.Diagnostics.Debug.WriteLine("Received from {0}:{1}", remote.RawName, string.Join(",", (from a in data select a.ToString("X2")).ToArray())); }
private static byte[] ReadPackageFromMessage(DatagramSocketMessageReceivedEventArgs message) { using (var reader = message.GetDataReader()) { if (reader.UnconsumedBufferLength != LightPiProtocol.PackageLength) { // Ignore all messages with a wrong package size. Debug.WriteLine($"Received invalid message with a length of {reader.UnconsumedBufferLength} bytes"); return(null); } var buffer = new byte[LightPiProtocol.PackageLength]; reader.ReadBytes(buffer); return(buffer); } }
private void HandleMessage(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs e) { try { using (var dataReader = e.GetDataReader()) { //dataReader.ByteOrder = ByteOrder.BigEndian; byte[] packet = new byte[dataReader.UnconsumedBufferLength]; dataReader.ReadBytes(packet); OnMessageReceived(packet); } } catch (Exception exception) { Debug.WriteLine(exception); } }
void socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { DataReader rd = args.GetDataReader(); uint length = rd.UnconsumedBufferLength; byte[] buffer = new byte[length]; rd.ReadBytes(buffer); processData(buffer); } catch (Exception e) { Debug.Log(e.ToString()); Debug.Log(SocketError.GetStatus(e.HResult).ToString()); return; } }
private void UdpMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { using (DataReader dataReader = args.GetDataReader()) { IBuffer buffer = dataReader.ReadBuffer(dataReader.UnconsumedBufferLength); byte[] bytes = buffer.ToArray(); Debug.WriteLine($"UDP receiving (from \"{args.RemoteAddress}\"): {string.Join(", ", bytes.Select(x => x.ToString("X2")))} ({bytes.Length} byte(s))."); } } catch (Exception exception) { Debug.WriteLine("UDP receive exception: " + exception); } }
//------------------------------------------------------------------------------------------------------------------------ #if UNIVERSAL private void _sock_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs e) { lock (this) { var address = e.RemoteAddress.ToString(); var port = int.Parse(e.RemotePort); //cleanup old CleanUp(); using (var reader = e.GetDataReader()) { var data = reader.DetachBuffer().ToArray().Skip(2).ToArray(); HandleNewPacket(data, address); } } }
private void OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { //Logger.Trace("OnMessageReceived: endpoint = {0}, port = {1}", args.RemoteAddress, args.RemotePort); var reader = args.GetDataReader(); var count = reader.UnconsumedBufferLength; var data = new byte[count]; reader.ReadBytes(data); lock (m_messages) { m_messages.Add(new Message { Data = data }); } m_messageReceivedEvent.Set(); }
public void OnDatagramMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { try { var reader = args.GetDataReader(); var length = reader.UnconsumedBufferLength; var received = reader.ReadString(length); foreach (var ch in received) { if (ch == '\r' || ch == '\n') { if (builder.Length > 0) { var logline = builder.ToString(); var m = SyslogRegex.Match(logline); if (m.Success) { if (ushort.TryParse(m.Groups["pri"].Value, out ushort pr)) { var f = (Facility)(pr >> 3); var p = (Priority)(pr & 7); var tag = m.Groups["tag"].Value as string; Received?.Invoke(this, new MessageEventArgs(f, p, DateTime.Now, tag, m.Groups["msg"].Value)); } else { Received?.Invoke(this, new MessageEventArgs(logline)); } } else { Received?.Invoke(this, new MessageEventArgs(logline)); } builder.Clear(); } } else { builder.Append(ch); } } } catch (Exception) { } }
async void udpMessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { if (!targetIPReady && !connected && !trashUDP) { trashUDP = true; DataReader reader = args.GetDataReader(); uint len = reader.UnconsumedBufferLength; string msg = reader.ReadString(len); string remoteHost = args.RemoteAddress.DisplayName; targetIP = msg; targetIPReady = true; await listenerSocket.CancelIOAsync(); listenerSocket.MessageReceived -= udpMessageReceived; listenerSocket.Dispose(); listenerSocket = null; } }
private void UDPReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { DataReader reader = args.GetDataReader(); try { uint len = reader.UnconsumedBufferLength; byte[] data = new byte[len]; reader.ReadBytes(data); _udpCallback(socket, data); } catch (Exception e) { SocketErrorStatus socketError = SocketError.GetStatus(e.HResult); throw; } reader.Dispose(); }
private void OnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { var dataReader = args.GetDataReader(); uint count = dataReader.UnconsumedBufferLength; if (count > 0) { byte[] data = new byte[count]; dataReader.ReadBytes(data); _incomingData.Enqueue( new IncomingData { EndPoint = new NetEndPoint(args.RemoteAddress, args.RemotePort), Data = data }); _receiveWaiter.Set(); } }
async void MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { if (ListenerMessageEvent != null) { var reader = new StreamReader(args.GetDataStream().AsStreamForRead()); var data = await reader.ReadLineAsync(); ListenerMessageEvent(data, args.RemoteAddress.DisplayName); } if (ListenerByteEvent != null) { var readData = args.GetDataReader(); var byteData = new byte[readData.UnconsumedBufferLength]; readData.ReadBytes(byteData); ListenerByteEvent(byteData, args.RemoteAddress.DisplayName); } }
private static async void MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var readPacket = args.GetDataReader(); if (readPacket == null) { Debug.WriteLine("DataReader is null"); return; } uint buffLen = readPacket.UnconsumedBufferLength; if (buffLen == 0) { Debug.WriteLine("Buffer is empty"); return; } if (!App.isRPi) { //GET FRAME var buffer = readPacket.ReadBuffer(buffLen); var stream = buffer.AsStream(); stream.Seek(0, SeekOrigin.Begin); IRandomAccessStream photoStream = stream.AsRandomAccessStream(); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { BitmapImage frame = new BitmapImage(); await frame.SetSourceAsync(photoStream); var currentPage = ((ContentControl)Window.Current.Content).Content as Page; var captureImage = currentPage.FindName("captureFrame") as Image; captureImage.Source = frame; }); } } catch (Exception ex) { Debug.WriteLine("MessageReceived() - " + ex.Message); } }
//private async void SocketOnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) //{ // var result = args.GetDataStream(); // var resultStream = result.AsStreamForRead(1024); // using (var reader = new StreamReader(resultStream)) // { // var text = await reader.ReadToEndAsync(); // } //} private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var r = args.GetDataReader(); var l = r.UnconsumedBufferLength; buffer = new byte[l]; r.ReadBytes(buffer); } catch (Exception exception) { SocketErrorStatus socketError = Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult); if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } } }
private void UdpSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var dr = args.GetDataReader(); dr.InputStreamOptions = InputStreamOptions.Partial; // | InputStreamOptions.ReadAhead; var udpResult = ReadUdp(dr); UdpResults.Add(sender.Information.LocalPort, udpResult); } catch (Exception ex) { // This can happen when we send a packet to a correct host (like localhost) but with an // incorrect service. The packet will "bounce", resuluting in a MessageReceived event // but with an args with no real data. Stats.NExceptions++; var delta = DateTime.UtcNow.Subtract(SocketStartTime).TotalSeconds; var udpResult = EchoResult.MakeFailed(ex, delta); UdpResults.Add(sender.Information.LocalPort, udpResult); } }
protected override void _socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { Debug.WriteLine(args.RemoteAddress.DisplayName); using (DataReader reader = args.GetDataReader()) { MessageModel message = MessageModel.ToMessage(reader); //byte[] data = new byte[reader.UnconsumedBufferLength]; //reader.ReadBytes(data); //MessageModel message = MessageModel.ToMessageFromEncrypted(data); switch (message.Type) { case MessageType.DeviceDetection: ResponseDeviceDetection(message, args.RemoteAddress); break; } MessageReceived?.Invoke(sender, message); } }
private void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { try { DataReader reader = args.GetDataReader(); reader.InputStreamOptions = InputStreamOptions.Partial; uint bytesRead = reader.UnconsumedBufferLength; String message = reader.ReadString(bytesRead); playPage.DisplayMessages(name + " :Message received [" + args.RemoteAddress.DisplayName.ToString() + "]:" + args.RemotePort + ": " + message); SendMessage(IPAdress.LocalIPAddress() + " " + name, args.RemoteAddress.DisplayName.ToString(), portSender); reader.Dispose(); } catch (Exception ex) { playPage.DisplayMessages(name + " :ERROR: Message received from:\n" + ex.ToString()); } }
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var connectionKey = GetConnectionKey(args.RemoteAddress, args.RemotePort); Connection connection; bool newConnection = false; lock (this.connectionCache) { if (!this.connectionCache.TryGetValue(connectionKey, out connection)) { connection = new Connection(); this.connectionCache.Add(connectionKey, connection); newConnection = true; } connection.Touch(); } var reader = args.GetDataReader(); string received = reader.ReadString(reader.UnconsumedBufferLength); var msg = DeserializeInternalMessage(received); var connectMessage = msg as Model.ConnectMessage; if (connectMessage != null) { if (newConnection) Debug.WriteLine("New connection {0}:{1} from host {2}", args.RemoteAddress, args.RemotePort, connectMessage.HostId); Debug.WriteLine("Connect from " + connectMessage.HostId); lock (this.hostIdLookup) { this.hostIdLookup[connectMessage.HostId] = connectionKey; } connection.HostId = connectMessage.HostId; // Send alive message Task.Run(async () => await SendAliveAsync(connectMessage.HostId)); } var payloadMessage = msg as Model.PayloadMessage; if (payloadMessage != null) { object payloadObject = DeserializePayload(payloadMessage.Payload); try { this.payloadReceivedAction?.Invoke(connection.HostId, payloadObject); } catch (Exception ex) { Debug.WriteLine("Exception while invoking callback with payload object " + ex.ToString()); } } } catch (Exception exception) { SocketErrorStatus socketError = SocketError.GetStatus(exception.HResult); if (socketError == SocketErrorStatus.ConnectionResetByPeer) { // This error would indicate that a previous send operation resulted in an // ICMP "Port Unreachable" message. //NotifyUserFromAsyncThread( // "Peer does not listen on the specific port. Please make sure that you run step 1 first " + // "or you have a server properly working on a remote server.", // NotifyType.ErrorMessage); } else if (socketError != SocketErrorStatus.Unknown) { //NotifyUserFromAsyncThread( // "Error happened when receiving a datagram: " + socketError.ToString(), // NotifyType.ErrorMessage); } else { throw; } } }