public async Task <bool> InitializeRecv() { recvInitialized = false; try { if (msocketRecv != null) { msocketRecv.MessageReceived -= UDPMulticastMessageReceived; msocketRecv.Dispose(); msocketRecv = null; } msocketRecv = new DatagramSocket(); msocketRecv.MessageReceived += UDPMulticastMessageReceived; NetworkAdapter adapter = GetDefaultNetworkAdapter(); if (adapter != null) { await msocketRecv.BindServiceNameAsync(mPort); } // await msocketRecv.BindServiceNameAsync(mPort, adapter); else { await msocketRecv.BindServiceNameAsync(mPort); } HostName mcast = new HostName(mAddress); msocketRecv.JoinMulticastGroup(mcast); mLastIDReceived = 0; recvInitialized = true; } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception while listening: " + e.Message); recvInitialized = false; } return(recvInitialized); }
async Task <bool> InitializeMulticastRecv() { try { if (msocketRecv != null) { msocketRecv.MessageReceived -= UDPMulticastMessageReceived; msocketRecv.Dispose(); msocketRecv = null; } msocketRecv = new DatagramSocket(); msocketRecv.Control.MulticastOnly = true; msocketRecv.MessageReceived += UDPMulticastMessageReceived; NetworkAdapter adapter = GetDefaultNetworkAdapter(SendInterfaceAddress); if (adapter != null) { await msocketRecv.BindServiceNameAsync(MulticastUDPPort.ToString(), adapter); } else { await msocketRecv.BindServiceNameAsync(MulticastUDPPort.ToString()); } HostName mcast = new HostName(MulticastIPAddress); msocketRecv.JoinMulticastGroup(mcast); return(true); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception while listening: " + e.Message); } return(false); }
/// <summary> /// Initiates the Discovery System Client. /// </summary> /// <param name="name">This is the port the system will listen for and broadcast udp packets</param> /// <param name="deviceInfo">A JSON object containing all the relevant device info</param> public override async void Initialize(string name, object deviceInfo) { Debug.WriteLine($"Discovery System: Initializing {name}"); try { // Set the device name this.name = name; // Set initial variables DeviceInfo = deviceInfo; // Setup a UDP socket listener socket.MessageReceived += ReceivedDiscoveryMessage; await socket.BindServiceNameAsync(udpPort.ToString()); // Tell the world you exist SendDiscoveryResponseMessage(); // Find out who else is out there Discover(); // Set up the rest API InitializeRestApi(tcpPort); Debug.WriteLine("Discovery System: Success"); } catch (Exception ex) { Debug.WriteLine("Discovery System: Failure"); Debug.WriteLine("Reason: " + ex.Message); } }
public async Task Bind() { if (string.IsNullOrEmpty(_datagram.Information.LocalPort)) { await _datagram.BindServiceNameAsync(_port.ToString()); } }
async Task <bool> InitializeUnicastRecv() { try { if (usocketRecv != null) { usocketRecv.MessageReceived -= UDPUnicastMessageReceived; usocketRecv.Dispose(); usocketRecv = null; } usocketRecv = new DatagramSocket(); usocketRecv.MessageReceived += UDPUnicastMessageReceived; // NetworkAdapter adapter = GetDefaultNetworkAdapter(); // if (adapter != null) // await msocketRecv.BindServiceNameAsync(UnicastUDPPort.ToString(), adapter); // else await usocketRecv.BindServiceNameAsync(UnicastUDPPort.ToString()); return(true); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception while listening: " + e.Message); } return(false); }
public async Task <bool> InitializeSend() { sendInitialized = false; try { if (msocketSend != null) { // msocketSend.MessageReceived -= UDPMulticastMessageReceived; msocketSend.Dispose(); msocketSend = null; } msocketSend = new DatagramSocket(); // msocketSend.MessageReceived += UDPMulticastMessageReceived; NetworkAdapter adapter = GetDefaultNetworkAdapter(); if (adapter != null) { await msocketSend.BindServiceNameAsync("", adapter); } mLastIDSent = 0; sendInitialized = true; } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception while initializing: " + e.Message); sendInitialized = false; } return(sendInitialized); }
async Task <bool> InitializeSend() { bool result = false; try { if (msocketSend != null) { msocketSend.Dispose(); msocketSend = null; } msocketSend = new DatagramSocket(); NetworkAdapter adapter = GetDefaultNetworkAdapter(SendInterfaceAddress); if (adapter != null) { await msocketSend.BindServiceNameAsync("", adapter); } result = true; } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Exception while initializing: " + e.Message); result = false; } return(result); }
private async void CreateSocketsAsync() { receivingUdp = new DatagramSocket(); receivingUdp.MessageReceived += ReceivingUdp_MessageReceived; await receivingUdp.BindServiceNameAsync(UDPListenerPort.ToString()); }
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()); } }
public static async Task ConnectAsync(string hostName = HOST_NAME, string port = REMOTE_PORT) { if (!StubMode) { #if WINDOWS_APP || WINDOWS_PHONE_APP // Set up the UDP connection. var droneIP = new HostName(hostName); udpSocket = new DatagramSocket(); await udpSocket.BindServiceNameAsync(port); await udpSocket.ConnectAsync(droneIP, port); udpWriter = new DataWriter(udpSocket.OutputStream); udpWriter.WriteByte(1); await udpWriter.StoreAsync(); #else udpSocket = new UdpClient(); udpSocket.Connect(hostName, int.Parse(port)); byte[] datagram = new byte[1] { 1 }; await udpSocket.SendAsync(datagram, datagram.Length); #endif } var loop = Task.Run(() => DroneLoop()); }
private async void FindHostIP() { //Open up a socket _listener = new DatagramSocket(); //Add MessageReceived Event _listener.MessageReceived += MessageReceived; //Important for async access CoreApplication.Properties.Add("listener", _listener); // Start listen operation. try { UpdateUi("Finding Ev3 IP Address.. Please Wait"); _listener.Control.InboundBufferSizeInBytes = _EV3_INBOUND_BUFFER_SIZE; //Await Message await _listener.BindServiceNameAsync(_EV3_PORT); } catch (Exception e) { UpdateUi(" Connection Error " + e.Message); } }
public UdpNetworkListenManager(int port) { #if UNITY_UWP Task.Run(async() => { socket = new DatagramSocket(); socket.MessageReceived += MessageReceived; await socket.BindServiceNameAsync(port.ToString()); }); #elif UNITY_EDITOR || UNITY_STANDALONE thread = new Thread(() => { ListenFlag = true; UdpClient udpclient = new UdpClient(port); udpclient.Client.ReceiveTimeout = 100; IPEndPoint remote = new IPEndPoint(IPAddress.Any, port); while (ListenFlag) { try { byte[] bytes = udpclient.Receive(ref remote); if (UdpNetworkListenEvent != null) { UdpNetworkListenEvent(Encoding.UTF8.GetString(bytes), remote.Address.ToString()); } } catch (Exception) { } } udpclient.Close(); }); thread.Start(); #endif }
/// <summary> /// Starts the listening for Udp-Broadcast Packets. /// </summary> public async void GetRobotUriAsync() { _listener = new DatagramSocket(); _listener.Control.InboundBufferSizeInBytes = 100; _listener.MessageReceived += Listener_MessageReceived; await _listener.BindServiceNameAsync(_port.ToString()); }
public async void InitializeSockets() { if (SocketsAreConnected) { return; } ab = new DatagramSocket(); scr = new DatagramSocket(); ab.MessageReceived += ClientSocketMessageReceived; scr.MessageReceived += ClientSocketMessageReceived2; try { await ab.BindServiceNameAsync("11444"); await scr.BindServiceNameAsync("11445"); } catch (Exception exception) { if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } // DebugLogOut("Error: Start Listen failed: " + exception.Message); return; } SocketsAreConnected = true; }
//Bind socket to port public bool Bind(ref NetEndPoint ep) { _datagramSocket = new DatagramSocket(); _datagramSocket.Control.DontFragment = true; _datagramSocket.MessageReceived += OnMessageReceived; try { if (ep.HostName == null) { _datagramSocket.BindServiceNameAsync(ep.PortStr).GetResults(); } else { _datagramSocket.BindEndpointAsync(ep.HostName, ep.PortStr).GetResults(); } ep = new NetEndPoint(_datagramSocket.Information.LocalAddress, _datagramSocket.Information.LocalPort); } catch (Exception) { return(false); } return(true); }
private async void StartUDPServer(string port) { var serverDatagramSocket = new DatagramSocket(); serverDatagramSocket.MessageReceived += ServerDatagramSocket_MessageReceived; await serverDatagramSocket.BindServiceNameAsync(port); }
static async Task BindToSocketAndWriteQuery(DatagramSocket socket, byte[] bytes, CancellationToken cancellationToken) { #if WINDOWS_UWP // Set control option for multicast. This enables re-use of the port, which is always in use under Windows 10 otherwise. socket.Control.MulticastOnly = true; #endif await socket.BindServiceNameAsync("5353") // binds to the local IP addresses of all network interfaces on the local computer if no adapter is specified .AsTask(cancellationToken) .ConfigureAwait(false); socket.JoinMulticastGroup(new HostName("224.0.0.251")); var os = await socket.GetOutputStreamAsync(new HostName("224.0.0.251"), "5353") .AsTask(cancellationToken) .ConfigureAwait(false); using (var writer = new DataWriter(os)) { writer.WriteBytes(bytes); await writer.StoreAsync() .AsTask(cancellationToken) .ConfigureAwait(false); Debug.WriteLine("Sent mDNS query"); writer.DetachStream(); } }
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 FalconOperationResult TryStart() { try { datagramSocket = new DatagramSocket(); SetEF(); datagramSocket.MessageReceived += OnMessageReceived; // HACK: We know this is not an async op and will be run in-line so avoid breaking our API // and "wait" for op to complete. // var asyncOp = datagramSocket.BindServiceNameAsync(localPeer.Port.ToString()); var task = asyncOp.AsTask(); task.Wait(); return(FalconOperationResult.SuccessResult); } catch (AggregateException aex) { // e.g. address already in use return(new FalconOperationResult(aex.InnerExceptions.Count > 0 ? aex.InnerExceptions[0] : aex)); } }
private async void ConnectUdpReceive_Click_1(object sender, RoutedEventArgs e) { try { if (receiveSocket == null) { receiveSocket = new DatagramSocket(); // MessageReceived handler must be set before BindServiceAsync is called, if not // "A method was called at an unexpected time. (Exception from HRESULT: // 0x8000000E)" exception is thrown. receiveSocket.MessageReceived += OnMessageReceived; // If port is already in used by another socket, "Only one usage of each socket // address (protocol/network address/port) is normally permitted. (Exception from // HRESULT: 0x80072740)" exception is thrown. await receiveSocket.BindServiceNameAsync("2704"); DisplayOutput(UdpReceiveOutput, "Connected (bound)."); } } catch (Exception ex) { DisplayOutput(UdpReceiveOutput, ex.ToString()); } }
public async void StartListening() { if (IsListening) { return; } IsListening = true; socket = new DatagramSocket(); socket.Control.MulticastOnly = false; socket.MessageReceived += SocketOnMessageReceived; try { await socket.BindServiceNameAsync(listenPort.ToString()); HostName remoteHost = new HostName("255.255.255.255"); IOutputStream outputStream = await socket.GetOutputStreamAsync(remoteHost, listenPort.ToString()); DataWriter writer = new DataWriter(outputStream); writer.WriteString("1"); await writer.StoreAsync(); } catch (Exception e) { } }
public IAsyncAction Start() { return(Task.Run(async() => { if (isStarted) { return; } multicastSsdpSocket = new DatagramSocket(); multicastSsdpSocket.MessageReceived += MulticastSsdpSocket_MessageReceived; multicastSsdpSocket.Control.MulticastOnly = true; await multicastSsdpSocket.BindServiceNameAsync(Constants.SSDP_PORT); multicastSsdpSocket.JoinMulticastGroup(Constants.SSDP_HOST); unicastLocalSocket = new DatagramSocket(); unicastLocalSocket.MessageReceived += UnicastLocalSocket_MessageReceived; await unicastLocalSocket.BindServiceNameAsync(""); logger.WriteLine($"ControlPoint: Bind to port :{unicastLocalSocket.Information.LocalPort} for UNICAST search responses."); NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged; networks = GetNetworks(); isStarted = true; logger.WriteLine("ControlPoint started."); }).AsAsyncAction()); }
public override async void Start() { if (_Started) { return; } _SequenceNumber = 1; // Connect To Drone udpClient = new DatagramSocket(); await udpClient.BindServiceNameAsync(_ServiceName); await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName); udpWriter = new DataWriter(udpClient.OutputStream); //string path = string.Format("AR.Drone-CommandHistory_{0:yyyy-MM-dd-HH-mm}.txt", DateTime.Now); //commandHistoryFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(path, CreationCollisionOption.ReplaceExisting); // Write first message //byte[] firstMessage = BitConverter.GetBytes(1); //WriteString(firstMessage.ToString()); udpWriter.WriteByte(1); await udpWriter.StoreAsync(); _Timer = ThreadPoolTimer.CreatePeriodicTimer(new TimerElapsedHandler(timerElapsedHandler), TimeSpan.FromMilliseconds(25)); _Started = true; }
/// <summary> /// This is only used by Webfront class. Thus only one listen Port while multiple send ports /// are used by Curtain Motor and light dimmers /// </summary> public void Initialise() { //Initialise the Automation Objects //Add the Automation Objects for (int i = 0; i < Constants.ROOMS; i++) { //Add Temperature Monitor Objects TemperatureMonitor tm = new TemperatureMonitor(); tm.EstablishConnection(Constants.TemperatureMonitorAddress[i], Constants.TEMPSOCKET); Temperatures.Add(tm); //Add Intruder Detectors IntruderDetect detector = new IntruderDetect(); detector.EstablishConnection(Constants.IntruderDetectAddress[i], Constants.INTRUDERSOCKET); Detectors.Add(detector); } //Initialise the buffer for storing Temperatures strings temperatureAlerts = new string[Constants.ROOMS]; for (int i = 0; i < Constants.ROOMS; i++) { temperatureAlerts[i] = "No Connectivity to Room: " + (i + 1).ToString() + "\n"; } GuestSocket.MessageReceived += MessageReceivedAsync; GuestSocket.BindServiceNameAsync(Constants.LISTENPORT).AsTask().Wait(); }
private async void Send_Click(object sender, RoutedEventArgs e) { Send.IsEnabled = false; var socket = new DatagramSocket(); try { var address = Address.Text.Split(':'); string host = address[0], port = address[1]; await socket.BindServiceNameAsync("1902"); var outputStream = await socket.GetOutputStreamAsync(new HostName(host), port); var writer = new DataWriter(outputStream); writer.WriteString(Message.Text); await writer.StoreAsync(); socket.Dispose(); } catch (Exception ex) { logger.WriteLine(ex.ToString()); } finally { socket.Dispose(); Send.IsEnabled = true; } }
private async Task JitterCalculation() { datagramSocket = new DatagramSocket(); datagramSocket.MessageReceived += delegate(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { System.Diagnostics.Debug.WriteLine("[ProfileNetworkFull]: Jitter Finish"); }; string port = server.JitterTestPort.ToString(); await datagramSocket.BindServiceNameAsync(port); using (DataWriter writer = new DataWriter(await datagramSocket.GetOutputStreamAsync(hostName, port))) { for (int i = 0; i < 21; i++) { writer.WriteString("jitter"); await writer.StoreAsync(); await writer.FlushAsync(); await Task.Delay(250); } } Close(ref datagramSocket); }
public static async Task Init() { ClearPrevious(); try { if (App.isRPi) { await InitCamera(1, IMAGE_QUALITY_PERCENT, VIDEO_SUBTYP, VIDEO_RES); socket = new DatagramSocket(); socket.MessageReceived += MessageReceived; HostName hn = new HostName(hostName); await socket.ConnectAsync(hn, hostPort).AsTask(); Debug.WriteLine("Connected to remote camera " + hn + ":" + hostPort); socketIsConnected = true; } else { listener = new DatagramSocket(); listener.MessageReceived += MessageReceived; await listener.BindServiceNameAsync(hostPort).AsTask(); Debug.WriteLine("Remote camera listening on port " + hostPort); listenerHasStarted = true; } } catch (Exception ex) { Debug.WriteLine("Error initializing camera: " + ex.Message); } }
private async Task Connect() { if (_isBound || _isBinding) { return; } lock (_lock) { if (_isBound || _isBinding) { return; } _isBinding = true; } var possibleConnectionProfiles = NetworkInformation.GetConnectionProfiles() .Where(p => p.IsWlanConnectionProfile && p.GetNetworkConnectivityLevel() != NetworkConnectivityLevel.None) .ToList(); var connectionProfile = possibleConnectionProfiles.FirstOrDefault(); if (connectionProfile != null) { await _socket.BindServiceNameAsync(_ipAddress.ServiceName, connectionProfile.NetworkAdapter); } _isBound = true; _isBinding = false; }
public DiscoveryServerService(ISettingsService settingsService) { _settingsService = settingsService ?? throw new ArgumentNullException(nameof(settingsService)); _socket.MessageReceived += SendResponseAsync; _socket.BindServiceNameAsync(Port.ToString()).GetAwaiter().GetResult(); }
public async void ConnectUDP(NetworkConnectionEndpoint remoteNetworkConnectionEndpoint) { if (!IsUDPSetup) { InitUDP(); } if (IsUDPConnected) { ResetUDP(); InitUDP(); } try { Debug.WriteLine("Binding UDPPort"); await m_datagramSocket.BindServiceNameAsync(remoteNetworkConnectionEndpoint.Port); Debug.WriteLine("Connecting UDPSocket"); await m_datagramSocket.ConnectAsync(remoteNetworkConnectionEndpoint.HostName, remoteNetworkConnectionEndpoint.Port); Debug.WriteLine("Creating UDPDataWriter"); m_udpDataWriter = new DataWriter(m_datagramSocket.OutputStream); Debug.WriteLine("Completed UDP"); UDPNetworkConnectionEndpoint = remoteNetworkConnectionEndpoint; IsUDPConnected = true; Debug.WriteLine("UDP Connected: " + UDPNetworkConnectionEndpoint.ToString()); } catch (Exception ex) { Debug.WriteLine(DebugTools.PrintOutException("ConnectUDP", ex)); } }
public bool Bind(int port) { _datagramSocket = new DatagramSocket(); _datagramSocket.Control.InboundBufferSizeInBytes = NetConstants.SocketBufferSize; _datagramSocket.Control.DontFragment = true; _datagramSocket.Control.OutboundUnicastHopLimit = NetConstants.SocketTTL; _datagramSocket.MessageReceived += OnMessageReceived; try { _datagramSocket.BindServiceNameAsync(port.ToString()).AsTask().Wait(); _datagramSocket.JoinMulticastGroup(MulticastAddressV6); _localEndPoint = new NetEndPoint(_datagramSocket.Information.LocalAddress, _datagramSocket.Information.LocalPort); } catch (Exception ex) { NetUtils.DebugWriteError("[B]Bind exception: {0}", ex.ToString()); return false; } return true; }