/// <summary> /// Initialize the connection to the network (prepare sockets, join multicast group, handle the right events, etc) /// </summary> /// <returns></returns> public void InitializeSockets() { if (Initialized) return; MulticastAddress = new HostName(MulticastAddressStr); // To receive packets (either unicast or multicast), a MessageReceived event handler must be defined // Initialize the multicast socket and register the event MulticastSocket = new DatagramSocket(); MulticastSocket.MessageReceived += MulticastSocketMessageReceived; // bind to a local UDP port MulticastSocket.BindServiceNameAsync(MulticastPortStr).AsTask().Wait(); // Call the JoinMulticastGroup method to join the multicast group. MulticastSocket.JoinMulticastGroup(MulticastAddress); // Get our IP address String MyIPString = PeerConnector.GetMyIP(); myIPAddress = new HostName(MyIPString); // Construct a list of ip addresses that should be ignored IgnoreableNetworkAddresses = new List<String> { LinkLocalPrefixString, LocalLoopbackPrefixString, PrivateNetworkPrefixString }; //, MyIPString }; System.Diagnostics.Debug.WriteLine("Ignored IP Addresses: " + LinkLocalPrefixString + " - " + LocalLoopbackPrefixString + " - " + PrivateNetworkPrefixString); TCPListener = new TCPSocketListener("80085", new TCPRequestHandler(ProcessNetworkObject)); TCPSocketHelper = new TCPSocketClient("80085"); TCPListener.Start(); Initialized = true; }
private void SetBackingSocket() { var socket = new DatagramSocket(); socket.MessageReceived += DatagramMessageReceived; _backingDatagramSocket = socket; }
private void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments) { DataReader reader; try { reader = eventArguments.GetDataReader(); } catch (Exception ex) { Debug.WriteLine("MessageReceived:" + ex); return; } uint dataLength = reader.UnconsumedBufferLength; byte[] data = new byte[dataLength]; reader.ReadBytes(data); var packet = new NavigationPacket { Timestamp = DateTime.UtcNow.Ticks, Data = data }; UpdateNavigationData(packet); _TimeoutStopWatch.Restart(); }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { // 多重イベントを抑制 //m_udp.MessageReceived -= Socket_MessageReceived; Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); int port; Int32.TryParse(args.RemotePort, out port); ReceiveDataType r = new ReceiveDataType(); try { r.data = await reader.ReadLineAsync(); r.remoteIP = new IPEndPoint(IPAddress.Parse(args.RemoteAddress.ToString()), port); m_receivedData.Enqueue(r); } catch (Exception e) { } // イベント発生を許可 //m_udp.MessageReceived += Socket_MessageReceived; }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); m_sStatus = "Message received: " + message; if (message.StartsWith("NAV")) { rotateCylinder(message); } else if (message.StartsWith("POS")) { performRaycast(message); } else if (message.StartsWith("ANNOTATION")) { processAnnotation(message); } else if (message.StartsWith("DEBUG")) { processDebug(message); } else if (message.StartsWith("MESSAGE")) { processMessage(message); } }
private void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Debug.Log("GOT MESSAGE FROM: " + args.RemoteAddress.DisplayName); //Read the message that was received from the UDP client. Stream streamIn = args.GetDataStream().AsStreamForRead(); MemoryStream ms = ToMemoryStream(streamIn); byte[] msgData = ms.ToArray(); /* * if (ExecuteOnMainThread.Count == 0) * { * ExecuteOnMainThread.Enqueue(() => * { * Debug.Log("ENQEUED "); * if (udpEvent != null){ * Debug.Log("Call udp event."); * udpEvent.Invoke(args.RemoteAddress.DisplayName, internalPort, msgData); * } * }); * } */ //string dataString = System.Text.Encoding.UTF8.GetString (msgData); string dataString = string.Join(" ", msgData); //Debug.Log(dataString); if (textUpdater != null) { //Debug.Log("Set text"); //textUpdater.setText(dataString); textUpdater.setText(msgData[0]); } }
private void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Debug.Log("Datagram socket message received"); //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); byte[] msg = ReadToEnd(streamIn); ArrayList messages = Osc.PacketToOscMessages(msg, msg.Length); foreach (OscMessage om in messages) { if (AllMessageHandler != null) { try { AllMessageHandler(om); } catch (Exception e) { Debug.Log(e.ToString()); return; } } } }
private void SendResponse(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { var controllerSettings = _settingsService.GetSettings<ControllerSettings>(); var response = new DiscoveryResponse(controllerSettings.Caption, controllerSettings.Description); SendResponseAsync(args.RemoteAddress, response).Wait(); }
public LightwaveUwpController(string ipAddress) { this.IpAddress = ipAddress; this.socket = new DatagramSocket(); ConnectionInProgress = false; _registerAttempts = 0; }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); Debug.Log("MESSAGE: " + message); if (ExecuteOnMainThread.Count == 0) { ExecuteOnMainThread.Enqueue(() => { Debug.Log("Enqueue MESSAGE: " + message); try { } catch (FormatException e) { Debug.Log(e.Message); } }); } }
public async Task Open() { //CheckBackgroundTask(); //await CheckSocketAsync(); #region Simple socket creation if (listenerSocket == null) { listenerSocket = new DatagramSocket(); listenerSocket.Control.DontFragment = true; listenerSocket.Control.MulticastOnly = true; listenerSocket.MessageReceived += DataReceived; try { await listenerSocket.BindServiceNameAsync(localService); listenerSocket.JoinMulticastGroup(new HostName(remoteMulticastAddress)); } catch (Exception exception) { Close(); // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) throw; //rootPage.NotifyUser("Start listening failed with error: " + exception.Message, NotifyType.ErrorMessage); } } #endregion }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { // lock multi event socket.MessageReceived -= Socket_MessageReceived; //Debug.Log("OSCSERVER UWP Socket_MessageReceived"); //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); byte[] bytes = reader.CurrentEncoding.GetBytes(reader.ReadToEnd()); streamIn.Dispose(); reader.Dispose(); OSCPacket packet = OSCPacket.Unpack(bytes); _lastReceivedPacket = packet; PacketReceivedEvent(this, _lastReceivedPacket); // unlock multi event socket.MessageReceived += Socket_MessageReceived; }
public override async void Start() { if (_Started) return; _SequenceNumber = 1; try { // Connect to the Drone udpClient = new DatagramSocket(); await udpClient.BindServiceNameAsync(_ServiceName); await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName); udpWriter = new DataWriter(udpClient.OutputStream); udpWriter.WriteByte(1); await udpWriter.StoreAsync(); _Timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(timerElapsedHandler), TimeSpan.FromMilliseconds(25)); _Started = true; } catch (Exception) { Stop(); } }
public static async void init(TiSettings settings) { if (!settings.ContainsKey("logToken") || settings["logToken"].Length == 0) { return; } logToken = settings["logToken"]; multicastSocket = new DatagramSocket(); multicastSocket.MessageReceived += multicastSocket_MessageReceived; HostName hostname = new HostName("239.6.6.6"); try { await multicastSocket.BindServiceNameAsync("8666"); multicastSocket.JoinMulticastGroup(hostname); IOutputStream stream = await multicastSocket.GetOutputStreamAsync(hostname, "8666"); DataWriter writer = new DataWriter(stream); writer.WriteString("TI_WP8_LOGGER"); await writer.StoreAsync(); writer.DetachStream(); stream.Dispose(); } catch (Exception ex) { if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) { throw; } Debug.WriteLine(ex.ToString()); } }
private async void btnConnect_Click(object sender, RoutedEventArgs e) { Windows.Networking.Sockets.DatagramSocket socket = new Windows.Networking.Sockets.DatagramSocket(); socket.MessageReceived += Socket_MessageReceived; //You can use any port that is not currently in use already on the machine. We will be using two separate and random //ports for the client and server because both the will be running on the same machine. string serverPort = "8001"; string clientPort = "8002"; //Because we will be running the client and server on the same machine, we will use localhost as the hostname. Windows.Networking.HostName serverHost = new Windows.Networking.HostName("127.0.0.1"); //Bind the socket to the clientPort so that we can start listening for UDP messages from the UDP echo server. await socket.BindServiceNameAsync(clientPort); await socket.ConnectAsync(serverHost, serverPort); //Write a message to the UDP echo server. Stream streamOut = (await socket.GetOutputStreamAsync(serverHost, serverPort)).AsStreamForWrite(); StreamWriter writer = new StreamWriter(streamOut); string message = "I'm the message from client!"; await writer.WriteLineAsync(message); await writer.FlushAsync(); }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); Debug.WriteLine("[Playback::Socket_MessageReceived] " + message); await Task.Run(() => { Task.Yield(); Logger.m_logger.addLog("Message received - " + message); }); if (message == "WARNING noHits") { await txNoHitsInfo.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Brush b = new SolidColorBrush(Windows.UI.Color.FromArgb(255, 0, 0, 0)); txNoHitsInfo.Foreground = b; }); // That way is not really recommended by Microsoft, but ... it seems to work. await Task.Delay(TimeSpan.FromSeconds(2)).ContinueWith(task => { txNoHitsInfo.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Brush b = new SolidColorBrush(Windows.UI.Color.FromArgb(0, 0, 0, 0)); txNoHitsInfo.Foreground = b; }); }); } }
public async Task ShutdownAsync() { IsRunning = false; //Wait for incoming messages to finish being processed DateTime timeoutTime = DateTime.Now.AddSeconds(5); while(messageReceiptAwaiters != null && messageReceiptAwaiters.Count > 0 && DateTime.Now < timeoutTime) { await Task.Delay(100); } messageReceiptAwaiters = null; if (socket != null) { try { socket.MessageReceived -= socket_MessageReceived; } catch(Exception ex) { //HACK: In testing I see the MessageReceived unsubscription throwing an InvalidOperationException saying 'A method was called at an unexpected time.' Debug.WriteLine(string.Format("{0} occurred while shutting down socket: {1}", ex.GetType().Name, ex.Message)); } socket.Dispose(); socket = null; } }
// メッセージを受信したらUIに見せる private void MessageReceived(Windows.Networking.Sockets.DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { try { var stringLength = args.GetDataReader().UnconsumedBufferLength; var receivedMessage = args.GetDataReader().ReadString(stringLength); NotifyUserFromAsyncThread( "Received data from remote peer: \"" + receivedMessage + "\"", NotifyType.StatusMessage); } catch (Exception exception) { var socketError = SocketError.GetStatus(exception.HResult); if (socketError == SocketErrorStatus.ConnectionResetByPeer) { 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 Init() { _Listener = new DatagramSocket(); _Listener.MessageReceived += Listener_MessageReceived; while (true) { try { await _Listener.BindServiceNameAsync("6"); break; } catch (COMException) { var messageDialog = new MessageDialog("Only one usage of each port is normally permitted.\r\n\r\nIs 'Windows IoT Core Watcher' open?", "Port in use"); messageDialog.Commands.Add(new UICommand("Try again", (command) => { })); await messageDialog.ShowAsync(); } } HostName hostname = new HostName("239.0.0.222"); _Listener.JoinMulticastGroup(hostname); _Settings = ApplicationData.Current.LocalSettings; _Timer = new Timer(Timer_Callback, null, 1000, 1000); }
async void datagramSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { i++; DataReader dataReader = args.GetDataReader(); uint length = dataReader.UnconsumedBufferLength; string content = dataReader.ReadString(length); Deployment.Current.Dispatcher.BeginInvoke(() => msgList.Children.Add(new TextBlock { Text = "服务器收到的消息:" + content })); //HostName hostName = new HostName("localhost"); //DatagramSocket datagramSocket = new DatagramSocket(); //IOutputStream outputStream = await datagramSocket.GetOutputStreamAsync(hostName, "22112"); DataWriter writer = new DataWriter(sender.OutputStream); writer.WriteString(content + "|" + i); try { await writer.StoreAsync(); msgList.Children.Add(new TextBlock { Text = "服务器发送的消息:" + content + "|" + i }); } catch (Exception err) { if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse) { } } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Debug.Log("GOT MESSAGE: "); //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); Debug.Log("MESSAGE: " + message); //Debug.Log(message.Length + " " + message[message.Length - 1]); //Debug.Log(message[0].Equals('<')); //Debug.Log(message[message.Length - 1].Equals('>')); string[] values = message.Split(','); if (values.Length == 4) { rocket.SetOrientation(float.Parse(values[0]), float.Parse(values[1]), float.Parse(values[2]), float.Parse(values[3])); } else if (values.Length == 3) { rocket.SetOrientation(float.Parse(values[0]), float.Parse(values[1]), float.Parse(values[2])); } }
/// <summary> /// Gets accurate time using the NTP protocol with default timeout of 45 seconds. /// </summary> /// <param name="timeout">Operation timeout.</param> /// <returns>Network accurate <see cref="DateTime"/> value.</returns> public async Task<DateTime> GetNetworkTimeAsync(TimeSpan timeout) { using (var socket = new DatagramSocket()) using (var ct = new CancellationTokenSource(timeout)) { ct.Token.Register(() => _resultCompletionSource.TrySetCanceled()); socket.MessageReceived += OnSocketMessageReceived; //The UDP port number assigned to NTP is 123 await socket.ConnectAsync(new HostName("pool.ntp.org"), "123"); using (var writer = new DataWriter(socket.OutputStream)) { // NTP message size is 16 bytes of the digest (RFC 2030) var ntpBuffer = new byte[48]; // Setting the Leap Indicator, // Version Number and Mode values // LI = 0 (no warning) // VN = 3 (IPv4 only) // Mode = 3 (Client Mode) ntpBuffer[0] = 0x1B; writer.WriteBytes(ntpBuffer); await writer.StoreAsync(); var result = await _resultCompletionSource.Task; return result; } } }
public async void PerformPeerDiscovery() { timer.Interval = new TimeSpan(0, 0, 5); timer.Start(); if (socket == null) { socket = new DatagramSocket(); socket.MessageReceived += socket_MessageReceived; try { await socket.BindEndpointAsync(null, "22002"); } catch { // Swallow any already bound exceptions! } } using (var outputStream = await socket.GetOutputStreamAsync(new HostName("230.0.0.1"), "22003")) { using (DataWriter wr = new DataWriter(outputStream)) { wr.WriteString("**BECHARMING DISCOVERY**"); await wr.FlushAsync(); await wr.StoreAsync(); } } }
private void MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { var stringLength = args.GetDataReader().UnconsumedBufferLength; var receivedMessage = args.GetDataReader().ReadString(stringLength); NotifyUserFromAsyncThread( "Received data from remote peer (Remote Address: " + args.RemoteAddress.CanonicalName + ", Remote Port: " + args.RemotePort + "): \"" + args.RemotePort + "): \"" + receivedMessage + "\"", NotifyType.StatusMessage); } catch (Exception e) { var socketError = SocketError.GetStatus(e.HResult); if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown) { throw; } _rootPage.NotifyUser("Error happend when receiving a datagram: " + e.Message, NotifyType.ErrorMessage); } }
void socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { DataReader dr = args.GetDataReader(); var dataLength = dr.UnconsumedBufferLength; string discoveryResult = dr.ReadString(dataLength); string[] parts = discoveryResult.Split('|'); string name = parts[0]; bool isPinProtected = bool.Parse(parts[1]); string uniqueName = parts[3]; var existingTarget = GetShareTarget(uniqueName); var discoveredTarget = new ShareTarget() { Name = name, IPAddress = args.RemoteAddress.DisplayName, IsPinCodeRequired = isPinProtected, ShareTargetUniqueName = uniqueName }; if (existingTarget != null) { discoveredTarget.ShareCount = existingTarget.ShareCount; } if (PeerDiscovered != null) { PeerDiscovered(discoveredTarget); } }
public async void DoesAThing() { var hostName = new HostName("stun.l.google.com"); var port = 19302; var taskCompletionSource = new TaskCompletionSource<StunUri>(); using (var datagramSocket = new DatagramSocket()) { datagramSocket.MessageReceived += async (sender, e) => { var buffer = await e.GetDataStream().ReadAsync(null, 100, InputStreamOptions.None).AsTask(); var stunMessage = StunMessage.Parse(buffer.ToArray()); var xorMappedAddressStunMessageAttribute = stunMessage.Attributes.OfType<XorMappedAddressStunMessageAttribute>().Single(); taskCompletionSource.SetResult(new StunUri(xorMappedAddressStunMessageAttribute.HostName, xorMappedAddressStunMessageAttribute.Port)); }; using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream()) { var stunMessageId = new StunMessageId(CryptographicBuffer.GenerateRandom(12).ToArray()); var stunMessageType = StunMessageType.BindingRequest; var stunMessageAttributes = new StunMessageAttribute[] { }; var stunMessage = new StunMessage(stunMessageType, stunMessageAttributes, stunMessageId); var bytes = stunMessage.ToLittleEndianByteArray(); var outputStream = await datagramSocket.GetOutputStreamAsync(hostName, $"{port}"); var written = await outputStream.WriteAsync(bytes.AsBuffer()); } } var result = await taskCompletionSource.Task; Assert.AreEqual(result.HostName, new HostName("200.100.50.25")); Assert.AreEqual(result.Port, 12345); }
private void ServerDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Debug.WriteLine("received packet"); Stream streamIn = args.GetDataStream().AsStreamForRead(); MemoryStream image = ToMemoryStream(streamIn); Save_Image(image); }
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { var dataReader = args.GetDataReader(); var length = dataReader.UnconsumedBufferLength; var message = dataReader.ReadString(length); var guidAsString = message.Replace("TT_DEVICE_IDENTIFIER:", "").Trim(); _deviceFoundCallback?.Invoke(new TickTackHub { Id = guidAsString }); }
private async Task<DatagramSocket> ListenForTack() { var socket = new DatagramSocket(); socket.MessageReceived += Socket_MessageReceived; await socket.BindServiceNameAsync(RemoteServiceName); Debug.WriteLine("Listening on {0}", RemoteServiceName); return socket; }
private async Task ExecuteDiscoveryTask() { int repeatTime = EndpointController.REPEAT_DISCOVERY_TASK / 2; while (running) { Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Started Cloudlet Discovery using Multicast UDP"); retry = 0; DatagramSocket socketSent = null; DatagramSocket socketReplay = null; try { socketSent = new DatagramSocket(); await socketSent.BindEndpointAsync(null, string.Empty); socketSent.JoinMulticastGroup(ip); socketReplay = new DatagramSocket(); socketReplay.MessageReceived += SocketOnMessageReceived; await socketReplay.BindServiceNameAsync(replyCloudletPort.ToString()); using (DataWriter writer = new DataWriter(await socketSent.GetOutputStreamAsync(ip, multicastPort.ToString()))) { while (retry < 60 && running) { writer.WriteString("mpos_cloudlet_req"); await writer.StoreAsync(); await writer.FlushAsync(); await Task.Delay(500); retry++; } } } catch (IOException e) { Debug.WriteLine("## [DiscoveryCloudletMulticast]: Any problem with i/o in multicast system!\n" + e.ToString()); } finally { socketSent.Dispose(); socketReplay.Dispose(); socketSent = null; socketReplay = null; } if (running) { Debug.WriteLine(">> [DiscoveryCloudletMulticast]: Retry Discovery Cloudlet, in " + repeatTime + " ms"); await Task.Delay(repeatTime); } else { Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Finished Discovery Cloudlet"); } } }
private async void ConnectSocket_Click(object sender, RoutedEventArgs e) { if (string.IsNullOrEmpty(ServiceNameForConnect.Text)) { _rootPage.NotifyUser("Please provide a service name.", NotifyType.ErrorMessage); return; } HostName hostName; try { hostName = new HostName(HostNameForConnect.Text); } catch (ArgumentException) { _rootPage.NotifyUser("Error: Invalid host name.", NotifyType.ErrorMessage); return; } if (CoreApplication.Properties.ContainsKey("clientSocket")) { _rootPage.NotifyUser("This step has already been executed. Please move to the next one.", NotifyType.ErrorMessage); return; } // クライアントソケットの作成 var socket = new Windows.Networking.Sockets.DatagramSocket(); if (DontFragment.IsOn) { // IPフラグメンテーションを許可しない socket.Control.DontFragment = true; } socket.MessageReceived += MessageReceived; CoreApplication.Properties.Add("clientSocket", socket); _rootPage.NotifyUser("Connecting to: " + HostNameForConnect.Text, NotifyType.StatusMessage); try { // サーバソケットに接続しにいく await socket.ConnectAsync(hostName, ServiceNameForConnect.Text); _rootPage.NotifyUser("Connected", NotifyType.StatusMessage); CoreApplication.Properties.Add("connected", null); } catch (Exception exception) { if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } _rootPage.NotifyUser("Connect failed with error: " + exception.Message, NotifyType.ErrorMessage); } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); message = await reader.ReadLineAsync(); }
private void CloseListenerSocket() { if (listenerSocket == null) { return; } listenerSocket.Dispose(); listenerSocket = null; }
/// <summary> /// Attempts to send a magic packet to the desination hostname, on the specified port with the specified MAC address. /// </summary> /// <param name="destination">Destination hostname or IP address.</param> /// <param name="destinationPort">Destination port number.</param> /// <param name="targetMac">Destination MAC address. Bytes can be separated by colons, dashes, or nothing.</param> /// <returns>True if magic packet is sent successfully, false otherwise.</returns> public async Task<bool> SendMagicPacket(Windows.Networking.HostName destination, uint destinationPort, string targetMac) { try { DatagramSocket _socket = new DatagramSocket(); using (var stream = await _socket.GetOutputStreamAsync(destination, destinationPort.ToString())) { //Split on common MAC separators char? splitChar = null; if (targetMac.Contains('-')) splitChar = '-'; else if (targetMac.Contains(':')) splitChar = ':'; else if (targetMac.Contains(' ')) splitChar = ' '; //Turn MAC into array of bytes byte[] macAsArray; if (splitChar != null) { macAsArray = targetMac.Split((char)splitChar) .Select(b => Convert.ToByte(b, 16)) .ToArray<byte>(); } else { //Jump through MAC-string, reading 2 chars at a time macAsArray = Enumerable.Range(0, targetMac.Length) .Where(x => x % 2 == 0) .Select(x => Convert.ToByte(targetMac.Substring(x, 2), 16)) //16 = hexadecimal .ToArray(); } List<byte> magicPacket = new List<byte> { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; //A WoLAN magic packet is just FF FF FF FF FF FF, then the target MAC adress repeated 16 times. for (int i = 0; i < 16; i++) { magicPacket = magicPacket.Concat(macAsArray).ToList(); } using (DataWriter writer = new DataWriter(stream)) { writer.WriteBytes(magicPacket.ToArray<byte>()); await writer.StoreAsync(); await writer.FlushAsync(); return true; } } } catch (Exception e) { Debug.WriteLine(e); return false; } }
// ===================================================== Code that only runs on UWP =====================================================================// #if NETFX_CORE private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadToEndAsync(); // this is a UDP message, so we can safely read all the lines messageQueue.Enqueue(message); }
public UdpTracker(Uri announceUrl) : base(announceUrl) { CanScrape = true; CanAnnounce = true; RetryDelay = TimeSpan.FromSeconds(15); _tracker = new DatagramSocket(); _tracker.MessageReceived += TrackerOnMessageReceived; }
private OSCClient(string ip) { _ip = ip; Socket = new DatagramSocket(); Socket.Control.DontFragment = true; Socket.Control.QualityOfService = SocketQualityOfService.Normal; Socket.MessageReceived += Socket_MessageReceived; }
void datagramSocket_MessageReceived2(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { i++; DataReader dataReader = args.GetDataReader(); uint length = dataReader.UnconsumedBufferLength; string content = dataReader.ReadString(length); Deployment.Current.Dispatcher.BeginInvoke(() => msgList.Children.Add(new TextBlock { Text = "客户端收到的消息:" + content })); }
public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); try { var details = taskInstance.TriggerDetails as SocketActivityTriggerDetails; var socketInformation = details.SocketInformation; switch (details.Reason) { case SocketActivityTriggerReason.SocketActivity: var socket = socketInformation.DatagramSocket; //DataReader reader = new DataReader(socket.InputStream); //reader.InputStreamOptions = InputStreamOptions.Partial; //await reader.LoadAsync(250); //var dataString = reader.ReadString(reader.UnconsumedBufferLength); ////ShowToast(dataString); //socket.TransferOwnership(socketInformation.Id); break; case SocketActivityTriggerReason.KeepAliveTimerExpired: socket = socketInformation.DatagramSocket; //DataWriter writer = new DataWriter(socket.OutputStream); //writer.WriteBytes(Encoding.UTF8.GetBytes("Keep alive")); //await writer.StoreAsync(); //writer.DetachStream(); //writer.Dispose(); //socket.TransferOwnership(socketInformation.Id); break; case SocketActivityTriggerReason.SocketClosed: socket = new DatagramSocket(); socket.EnableTransferOwnership(taskInstance.Task.TaskId, SocketActivityConnectedStandbyAction.Wake); //if (ApplicationData.Current.LocalSettings.Values["hostname"] == null) //{ // break; //} //var hostname = (String) ApplicationData.Current.LocalSettings.Values["hostname"]; //var port = (String) ApplicationData.Current.LocalSettings.Values["port"]; //await socket.ConnectAsync(new HostName(hostname), port); socket.TransferOwnership(socketId); break; default: break; } deferral.Complete(); } catch (Exception ex) { //ShowToast(ex.Message); deferral.Complete(); } }
private void CloseListenerSocket() { if (listenerSocket != null) { // DatagramSocket.Close() is exposed through the Dispose() method in C#. // The call below explicitly closes the socket, freeing the UDP port that it is currently bound to. listenerSocket.Dispose(); listenerSocket = null; } }
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { uint stringLength = args.GetDataReader().UnconsumedBufferLength; byte[] result = new byte[args.GetDataReader().UnconsumedBufferLength]; args.GetDataReader().ReadBytes(result); OSCPacket message = OSCPacket.Unpack(result); if (OnReceive != null) OnReceive(message); }
public void Start() { _socket = new DatagramSocket(); _socket.Control.DontFragment = true; _socket.ConnectAsync(new HostName("255.255.255.255"), "19227").AsTask().Wait(); _outputStream = _socket.OutputStream.AsStreamForWrite(); _timer.Change(0, Timeout.Infinite); }
private async Task SendResponseAsync(HostName target, DiscoveryResponse response) { var buffer = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)); using (var socket = new DatagramSocket()) { await socket.ConnectAsync(target, DEFAULT_PORT.ToString()); await socket.OutputStream.WriteAsync(buffer.AsBuffer()); await socket.OutputStream.FlushAsync(); } }
private static void DatagramSocket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { using (DataReader reader = args.GetDataReader()) { byte[] b = new byte[48]; reader.ReadBytes(b); App.NtpTimeOffset = GetNetworkTime(b) - DateTime.UtcNow; } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = reader.ReadToEnd(); Debug.Log("MESSAGE: " + message); text = message; }
private async void UDPListener_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { string request = ""; using (var streamReader = new StreamReader(args.GetDataStream().AsStreamForRead())) { request = await streamReader.ReadLineAsync(); } Debug(string.Format("recieved: " + request + "from:" + args.RemoteAddress.CanonicalName)); }
private async void ServerDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { string request; using (DataReader dataReader = args.GetDataReader()) { request = dataReader.ReadString(dataReader.UnconsumedBufferLength).Trim(); } await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => this.serverListBox.Items.Add(string.Format("server received the request: \"{0}\"", request))); }
/// <summary> /// Get available Webservices /// </summary> /// internal async Task <int> GetAvailableWSEndpointsInternal() { int ret = 0; try { this.Status = -2; m_endPoints.Clear(); IsNotWorking = false; using (var socket = new Windows.Networking.Sockets.DatagramSocket()) { // Set the callback for servers' responses // await m_MessageReceive.WaitAsync(); socket.MessageReceived += SocketOnMessageReceived; // Start listening for servers' responses await socket.BindServiceNameAsync(m_ListenPort.ToString()); // Send a search message await SendMessage(socket); bool bTimeOut = false; ThreadPoolTimer timer = ThreadPoolTimer.CreateTimer((t) => { bTimeOut = true; m_signal.Release(); }, TimeSpan.FromSeconds(m_timeOut + 2)); // Timeout +2 await m_signal.WaitAsync(); timer.Cancel(); timer = null; if (bTimeOut) { ret = -1; await socket.CancelIOAsync(); } else { ret = 1; } } } catch (Exception) { m_signal.Release(); ret = -1; } IsNotWorking = true; this.Status = ret; return(ret); }
/// <summary> /// Returns list of bridge IPs /// </summary> /// <returns></returns> public async Task<IEnumerable<string>> LocateBridgesAsync(TimeSpan timeout) { if (timeout <= TimeSpan.Zero) throw new ArgumentException("Timeout value must be greater than zero.", "timeout"); var discoveredDevices = new List<string>(); var multicastIP = new HostName("239.255.255.250"); using (var socket = new DatagramSocket()) { //Handle MessageReceived socket.MessageReceived += (sender, e) => { var reader = e.GetDataReader(); var bytesRemaining = reader.UnconsumedBufferLength; var receivedString = reader.ReadString(bytesRemaining); var location = receivedString.Substring(receivedString.ToLower().IndexOf("location:", System.StringComparison.Ordinal) + 9); receivedString = location.Substring(0, location.IndexOf("\r", System.StringComparison.Ordinal)).Trim(); discoveredDevices.Add(receivedString); }; await socket.BindEndpointAsync(null, string.Empty); socket.JoinMulticastGroup(multicastIP); var start = DateTime.Now; do { using (var stream = await socket.GetOutputStreamAsync(multicastIP, "1900")) using (var writer = new DataWriter(stream)) { string request = "M-SEARCH * HTTP/1.1\r\n" + "HOST:239.255.255.250:1900\r\n" + //"ST:urn:schemas-upnp-org:device:Basic:1\r\n" + //Alternative // "ST:upnp:rootdevice\r\n" + //Alternative "ST:SsdpSearch:all\r\n" + "MAN:\"ssdp:discover\"\r\n" + "MX:3\r\n\r\n\r\n"; writer.WriteString(request.ToString()); await writer.StoreAsync(); } } while (DateTime.Now.Subtract(start) < timeout); // try for thee seconds } return await FilterBridges(discoveredDevices); }
void timer_Tick(object sender, object e) { timer.Stop(); socket.Dispose(); socket = null; if (PeerDiscoveryComplete != null) { PeerDiscoveryComplete(this, null); } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Debug.Log("Triggering new message!"); //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); messages.Add(message); Debug.Log("MESSAGE: " + message); }
//private void DataReceived(object o) private void DataSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { try { var reader = args.GetDataReader(); byte[] data = new byte[reader.UnconsumedBufferLength]; args.GetDataReader().ReadBytes(data); this.socket = sender; var dhcpRequest = new DHCPRequest(data, socket, this); //ccDHCP = new clsDHCP(); //data is now in the structure //get the msg type OnDataReceived(this, dhcpRequest); var msgType = dhcpRequest.GetMsgType(); switch (msgType) { case DHCPMsgType.DHCPDISCOVER: OnDiscover(this, dhcpRequest); break; case DHCPMsgType.DHCPREQUEST: OnRequest(this, dhcpRequest); break; case DHCPMsgType.DHCPDECLINE: OnDecline(this, dhcpRequest); break; case DHCPMsgType.DHCPRELEASE: OnReleased(this, dhcpRequest); break; case DHCPMsgType.DHCPINFORM: OnInform(this, dhcpRequest); break; //default: // Console.WriteLine("Unknown DHCP message: " + (int)MsgTyp + " (" + MsgTyp.ToString() + ")"); // break; } } catch (Exception ex) { if (UnhandledException != null) { UnhandledException(this, ex); } } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); Debug.WriteLine("[Playback::Socket_MessageReceived] " + message); if (message == "CALL start") { if (m_bIsConnected == false) { ushort usPortRemotVideo; ushort.TryParse(m_sPortRemoteVideo, out usPortRemotVideo); bool statusConnection = await connect(m_sIPRemoteVideo, usPortRemotVideo); if (statusConnection) { await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { StartPlayback(m_sIPRemoteVideo, m_sPortRemoteVideo); }); await videoPlayer.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { videoPlayer.Visibility = Visibility.Visible; }); m_bIsConnected = true; } } } else if (message == "WARNING noHits") { await txNoHitsInfo.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Brush b = new SolidColorBrush(Windows.UI.Color.FromArgb(255, 0, 0, 0)); txNoHitsInfo.Foreground = b; }); // That way is not really recommended by Microsoft, but ... it seems to work. await Task.Delay(TimeSpan.FromSeconds(2)).ContinueWith(task => { txNoHitsInfo.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { Brush b = new SolidColorBrush(Windows.UI.Color.FromArgb(0, 0, 0, 0)); txNoHitsInfo.Foreground = b; }); }); } }
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Debug.Log("Received message: "); //Read the message that was received from the UDP echo client. Stream streamIn = args.GetDataStream().AsStreamForRead(); StreamReader reader = new StreamReader(streamIn); string message = await reader.ReadLineAsync(); Debug.Log("Message: " + message); lastReceivedUDPPacket = message; receivedUDPPacketQueue.Enqueue(message); }
private void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { //Read the message that was received from the UDP client. Stream streamIn = args.GetDataStream().AsStreamForRead(); MemoryStream ms = ToMemoryStream(streamIn); byte[] msgData = ms.ToArray(); if (ExecuteOnMainThread.Count == 0) { ExecuteOnMainThread.Enqueue(() => { InterpreteUDPData(msgData); }); } }
private async void UDPClientReceiver_Init() { try { // UDP通信インスタンスの初期化 p_Socket = new Windows.Networking.Sockets.DatagramSocket(); // 受信時のコールバック関数を登録する p_Socket.MessageReceived += OnMessage; // 指定のポートで受信を開始する p_Socket.BindServiceNameAsync(UDPReceivePort.ToString()); } catch (System.Exception e) { Debug.LogError(e.ToString()); } }
/// <summary> /// Event handler that gets called when a message is received on the socket /// </summary> /// <param name="sender"></param> /// <param name="data"></param> private static void MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { Stream streamIn = args.GetDataStream().AsStreamForRead(); byte[] byteArray; // Use the memory stream to convert the stream to a byte array using (var memoryStream = new MemoryStream()) { streamIn.CopyTo(memoryStream); byteArray = memoryStream.ToArray(); } // Data received, create a new NetworkMessage byte messageId = byteArray[0]; // Remove the message ID from the data byte[] message = new byte[byteArray.Length - 1]; for (int i = 1; i < byteArray.Length; ++i) { message[i - 1] = byteArray[i]; } // Build network message NetworkMessage nm = new NetworkMessage(messageId, message); // Call the correct callback method if (SocketClientManager.callbackMethods.ContainsKey(messageId)) { // Catch any exceptions and rethrow them, // so a user gets a good exception instead of a // object disposed exception try { SocketClientManager.callbackMethods[messageId](nm); } catch (Exception e) { throw e; } } else { PrintDebug("No known callback for message ID " + messageId.ToString()); } }
async void OnMessage (Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) { using (System.IO.Stream stream = args.GetDataStream().AsStreamForRead()) { // 受信データを取得 byte[] receiveBytes = new byte[MAX_BUFFER_SIZE]; await stream.ReadAsync(receiveBytes, 0, MAX_BUFFER_SIZE); lock (p_LockObject) { // 受信データを処理に引き渡す UDPReceiveEvent(receiveBytes); } } }
async partial void SendTimeRequest() { var socket = new Windows.Networking.Sockets.DatagramSocket(); AsyncUdpResult asyncResult = null; try { var buffer = new byte[48]; buffer[0] = 0x1B; socket.MessageReceived += Socket_Completed_Receive; asyncResult = new AsyncUdpResult(socket); await socket.ConnectAsync(new Windows.Networking.HostName(_ServerAddress), "123").AsTask().ConfigureAwait(false); using (var udpWriter = new DataWriter(socket.OutputStream)) { udpWriter.WriteBytes(buffer); await udpWriter.StoreAsync().AsTask().ConfigureAwait(false); udpWriter.WriteBytes(buffer); await udpWriter.StoreAsync().AsTask().ConfigureAwait(false); asyncResult.Wait(OneSecond); } } catch (Exception ex) { try { if (socket != null) { ExecuteWithSuppressedExceptions(() => socket.MessageReceived -= this.Socket_Completed_Receive); ExecuteWithSuppressedExceptions(() => socket.Dispose()); } } finally { OnErrorOccurred(ExceptionToNtpNetworkException(ex)); } } finally { asyncResult?.Dispose(); } }
internal async void Start() { try { var DataSocket = new Windows.Networking.Sockets.DatagramSocket(); DataSocket.MessageReceived += DataSocket_MessageReceived; await DataSocket.BindEndpointAsync(new Windows.Networking.HostName(_bindIp.ToString()), PORT_TO_LISTEN_TO.ToString()); } catch (Exception ex) { if (UnhandledException != null) { UnhandledException(this, ex); } } }