| public BindServiceNameAsync ( [ localServiceName ) : IAsyncAction | ||
| localServiceName | [ | |
| return | IAsyncAction | |
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);
}
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();
}
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 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();
}
}
/// <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;
}
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 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");
}
}
}
/// <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);
}
private async Task<DatagramSocket> ListenForTick(NetworkAdapter hostname)
{
var socket = new DatagramSocket();
socket.MessageReceived += OnMessageReceived;
await socket.BindServiceNameAsync(Settings.RemoteServiceName, hostname);
socket.JoinMulticastGroup(new HostName(Settings.MulticastAddress));
Log($"Listening on {hostname.NetworkAdapterId}:{Settings.RemoteServiceName}");
return socket;
}
public async void StartServer(string port)
{
_socket = new DatagramSocket();
var control = _socket.Control;
_socket.MessageReceived += OnMessageRecived;
await _socket.BindServiceNameAsync(port);
var host = new HostName("192.168.137.1");
var outputStream = await _socket.GetOutputStreamAsync(host, "8001");
_writer = new DataWriter(outputStream);
}
public override async void Start()
{
udpClient = new DatagramSocket();
// Connect To Drone
udpClient.MessageReceived += MessageReceived;
await udpClient.BindServiceNameAsync(_ServiceName);
await udpClient.ConnectAsync(new HostName(DroneClient.Host), _ServiceName);
udpWriter = new DataWriter(udpClient.OutputStream);
SendKeepAliveSignal();
_TimeoutStopWatch = Stopwatch.StartNew();
}
private async Task DoWakeOnLan(string macAddress, string ipAddress, string port)
{
var socket = new DatagramSocket();
await socket.BindServiceNameAsync("0");
var o = await socket.GetOutputStreamAsync(new HostName(ipAddress), port);
var writer = new DataWriter(o);
writer.WriteBytes(GetBuffer(macAddress));
await writer.StoreAsync();
socket.Dispose();
}
private async Task SendTick()
{
using (var socket = new DatagramSocket())
{
await socket.BindServiceNameAsync(string.Empty);
socket.JoinMulticastGroup(new HostName(BroadcastAddress));
var outputStream =
await socket.GetOutputStreamAsync(new HostName(BroadcastAddress), RemoteServiceName);
var buffer = Encoding.UTF8.GetBytes("TT_SEND_DEVICE_INFO");
await outputStream.WriteAsync(buffer.AsBuffer());
await outputStream.FlushAsync();
Debug.WriteLine("TICK Broadcasted to {0}:{1}", BroadcastAddress, RemoteServiceName);
}
}
private async void Search(string st, TimeSpan? timeout = null)
{
Log("Search - " + st);
var ssdp_data = new StringBuilder()
.Append("M-SEARCH * HTTP/1.1").Append("\r\n")
.Append("HOST: ").Append(MULTICAST_ADDRESS).Append(":").Append(SSDP_PORT.ToString()).Append("\r\n")
.Append("MAN: ").Append("\"ssdp:discover\"").Append("\r\n")
.Append("MX: ").Append(MX.ToString()).Append("\r\n")
.Append("ST: ").Append(st).Append("\r\n")
.Append("\r\n")
.ToString();
var adapters = TargetNetworkAdapters ?? await GetActiveAdaptersAsync().ConfigureAwait(false);
await Task.WhenAll(adapters.Select(async adapter =>
{
using (var socket = new DatagramSocket())
{
socket.Control.DontFragment = true;
socket.MessageReceived += OnDatagramSocketMessageReceived;
try
{
await socket.BindServiceNameAsync("", adapter);
using (var output = await socket.GetOutputStreamAsync(MULTICAST_HOST, SSDP_PORT.ToString()))
{
using (var writer = new DataWriter(output))
{
writer.WriteString(ssdp_data);
await writer.StoreAsync();
}
}
await Task.Delay(timeout ?? DEFAULT_TIMEOUT).ConfigureAwait(false);
Log("Search Timeout");
await socket.CancelIOAsync();
}
catch (Exception e)
{
Log("Failed to send multicast: " + e.StackTrace);
}
socket.MessageReceived -= OnDatagramSocketMessageReceived;
}
})).ConfigureAwait(false);
Finished?.Invoke(this, new EventArgs());
}
public async void SendMessage()
{
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.
//Because we will be running the client and server on the same machine, we will use localhost as the hostname.
//Bind the socket to the clientPort so that we can start listening for UDP messages from the UDP echo server.
await socket.BindServiceNameAsync(clientPort);
//Write a message to the UDP echo server.
}
/// <summary>
/// 在此页将要在 Frame 中显示时进行调用。
/// </summary>
/// <param name="e">描述如何访问此页的事件数据。Parameter
/// 属性通常用于配置页。</param>
async protected override void OnNavigatedTo(NavigationEventArgs e)
{
// 创建一个新的socket实例，并绑定到一个本地端口上
DatagramSocket udpSocket = new DatagramSocket();
await udpSocket.BindServiceNameAsync("3721");
// 打开一个连接到远程主机上
HostName remoteHost = new HostName("192.168.1.100");
await udpSocket.ConnectAsync(remoteHost, "3721");
// 将一个字符串以UDP数据包形式发送到远程主机上
DataWriter udpWriter = new DataWriter(udpSocket.OutputStream);
udpWriter.WriteString("这里是破船之家");
await udpWriter.StoreAsync();
}
/// <summary>
/// Start listening.
/// </summary>
public override async Task<bool> StartListeningAsync()
{
bool status = false;
if (_listenerSocket == null)
{
_listenerSocket = new DatagramSocket();
_listenerSocket.MessageReceived += AdvertisementMessageReceivedFromManagerAsync;
await _listenerSocket.BindServiceNameAsync(ListenerPort);
_listenerSocket.JoinMulticastGroup(ListenerGroupHost);
status = true;
}
return status;
}
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());
}
}
private async void StartClick(object sender, RoutedEventArgs e)
{
try
{
datagramSocket = new DatagramSocket();
datagramSocket.MessageReceived += MessageReceived;
await datagramSocket.BindServiceNameAsync(port.ToString());
this.OutputString("Done!");
}
catch (Exception ex)
{
datagramSocket = null;
this.OutputString(ex.Message);
}
}
public async void Start()
{
socket = new DatagramSocket();
socket.MessageReceived += socket_MessageReceived;
try
{
await socket.BindServiceNameAsync(config.Port.ToString());
}
catch (Exception e)
{
Debug.Log(e.ToString());
Debug.Log(SocketError.GetStatus(e.HResult).ToString());
return;
}
}
private async void listener_Click(object sender, RoutedEventArgs e)
{
DatagramSocket datagramSocket = new DatagramSocket();
datagramSocket.MessageReceived += datagramSocket_MessageReceived;
try
{
await datagramSocket.BindServiceNameAsync("22112");
msgList.Children.Add(new TextBlock { Text = "监听成功" });
}
catch (Exception err)
{
if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
{
}
}
}
public override async void Start()
{
if (Status == ListenerStatus.Listening)
return;
try
{
_datagramSocket = new DatagramSocket();
_datagramSocket.MessageReceived += DatagramSocketOnMessageReceived;
await _datagramSocket.BindServiceNameAsync(MulticastPort.ToString());
_datagramSocket.JoinMulticastGroup(MulticastIpAddress);
RaiseStatusChanged(ListenerStatus.Listening);
}
catch
{
RaiseStatusChanged(ListenerStatus.PortNotFree);
}
}
//
// Constructor
//
public DiscoveryServer(DiscoveryMode mode)
{
m_mode = mode;
m_dataSocket = new DatagramSocket();
// Register for message callbacks. We do this both on the server and client
// so the client can invoke the server when it comes online.
m_dataSocket.MessageReceived += DataSocket_MessageRecieved;
new Task(async () =>
{
try
{
await m_dataSocket.BindServiceNameAsync(GLOW_SERVER_DISCOVER_PORT + "");
}
catch(Exception e)
{
System.Diagnostics.Debug.WriteLine("UDP unable to bind to port!. Message: " + e.Message);
}
}).Start();
}
public static IObservable<ZeroconfRecord> Resolve(string protocol)
{
return Observable.Create<ZeroconfRecord>(async observer =>
{
var socket = new DatagramSocket();
var s = Observable
.FromEventPattern
<TypedEventHandler<DatagramSocket, DatagramSocketMessageReceivedEventArgs>,
DatagramSocketMessageReceivedEventArgs>(
x => socket.MessageReceived += x, _ => socket.Dispose())
.Select(ProcessMessage)
.Where(x => x != null)
.Subscribe(observer);
await socket.BindServiceNameAsync("5353");
socket.JoinMulticastGroup(new HostName("224.0.0.251"));
var os = await socket.GetOutputStreamAsync(new HostName("224.0.0.251"), "5353");
var writer = new DataWriter(os);
WriteQueryMessage(protocol, writer);
writer.StoreAsync();
return s;
});
}
private static async Task BindToSocketAndWriteQuery(DatagramSocket socket, byte[] bytes, CancellationToken cancellationToken)
{
await socket.BindServiceNameAsync("5353")
.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;
// 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 the click handler for the 'StartListener' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void StartListener_Click(object sender, RoutedEventArgs e)
{
if (String.IsNullOrEmpty(ServiceName.Text))
{
rootPage.NotifyUser("Please provide a service name.", NotifyType.ErrorMessage);
return;
}
if (listenerSocket != null)
{
rootPage.NotifyUser("A listener socket is already set up.", NotifyType.ErrorMessage);
return;
}
bool isMulticastSocket = (MulticastRadioButton.IsChecked == true);
listenerSocket = new DatagramSocket();
listenerSocket.MessageReceived += MessageReceived;
if (isMulticastSocket)
{
// DatagramSockets conduct exclusive (SO_EXCLUSIVEADDRUSE) binds by default, effectively blocking
// any other UDP socket on the system from binding to the same local port. This is done to prevent
// other applications from eavesdropping or hijacking a DatagramSocket's unicast traffic.
//
// Setting the MulticastOnly control option to 'true' enables a DatagramSocket instance to share its
// local port with any Win32 sockets that are bound using SO_REUSEADDR/SO_REUSE_MULTICASTPORT and
// with any other DatagramSocket instances that have MulticastOnly set to true. However, note that any
// attempt to use a multicast-only DatagramSocket instance to send or receive unicast data will result
// in an exception being thrown.
//
// This control option is particularly useful when implementing a well-known multicast-based protocol,
// such as mDNS and UPnP, since it enables a DatagramSocket instance to coexist with other applications
// running on the system that also implement that protocol.
listenerSocket.Control.MulticastOnly = true;
}
// Start listen operation.
try
{
await listenerSocket.BindServiceNameAsync(ServiceName.Text);
if (isMulticastSocket)
{
// Join the multicast group to start receiving datagrams being sent to that group.
listenerSocket.JoinMulticastGroup(new HostName(RemoteAddress.Text));
rootPage.NotifyUser(
"Listening on port " + listenerSocket.Information.LocalPort + " and joined to multicast group",
NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser(
"Listening on port " + listenerSocket.Information.LocalPort,
NotifyType.StatusMessage);
}
// Enable scenario steps that require us to have an active listening socket.
SendMessageButton.IsEnabled = true;
CloseListenerButton.IsEnabled = true;
}
catch (Exception exception)
{
listenerSocket.Dispose();
listenerSocket = null;
// 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);
}
}
/// <summary>
/// This is the click handler for the 'StartListener' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void StartListener_Click(object sender, RoutedEventArgs e)
{
if (String.IsNullOrEmpty(ServiceNameForListener.Text))
{
rootPage.NotifyUser("Please provide a service name.", NotifyType.ErrorMessage);
return;
}
if (CoreApplication.Properties.ContainsKey("listener"))
{
rootPage.NotifyUser(
"This step has already been executed. Please move to the next one.",
NotifyType.ErrorMessage);
return;
}
CoreApplication.Properties.Remove("serverAddress");
DatagramSocket listener = new DatagramSocket();
listener.MessageReceived += MessageReceived;
if (!String.IsNullOrWhiteSpace(InboundBufferSize.Text))
{
uint inboundBufferSize = 0;
if (!uint.TryParse(InboundBufferSize.Text, out inboundBufferSize))
{
rootPage.NotifyUser(
"Please provide a positive numeric Inbound buffer size.",
NotifyType.ErrorMessage);
return;
}
try
{
// Running both client and server on localhost will most likely not reach the buffer limit.
// Refer to the DatagramSocketControl class' MSDN documentation for the full list of control options.
listener.Control.InboundBufferSizeInBytes = inboundBufferSize;
}
catch (ArgumentException)
{
rootPage.NotifyUser("Please provide a valid Inbound buffer size.", NotifyType.ErrorMessage);
return;
}
}
LocalHostItem selectedLocalHost = null;
if ((BindToAddress.IsChecked == true) || (BindToAdapter.IsChecked == true))
{
selectedLocalHost = (LocalHostItem)AdapterList.SelectedItem;
if (selectedLocalHost == null)
{
rootPage.NotifyUser("Please select an address / adapter.", NotifyType.ErrorMessage);
return;
}
// The user selected an address. For demo purposes, we ensure that connect will be using the same
// address.
CoreApplication.Properties.Add("serverAddress", selectedLocalHost.LocalHost.CanonicalName);
}
// Save the socket, so subsequent steps can use it.
CoreApplication.Properties.Add("listener", listener);
// Start listen operation.
try
{
if (BindToAny.IsChecked == true)
{
// Don't limit traffic to an address or an adapter.
await listener.BindServiceNameAsync(ServiceNameForListener.Text);
rootPage.NotifyUser("Listening", NotifyType.StatusMessage);
}
else if (BindToAddress.IsChecked == true)
{
// Try to bind to a specific address.
await listener.BindEndpointAsync(selectedLocalHost.LocalHost, ServiceNameForListener.Text);
rootPage.NotifyUser(
"Listening on address " + selectedLocalHost.LocalHost.CanonicalName,
NotifyType.StatusMessage);
}
else if (BindToAdapter.IsChecked == true)
{
// Try to limit traffic to the selected adapter.
// This option will be overriden by interfaces with weak-host or forwarding modes enabled.
NetworkAdapter selectedAdapter = selectedLocalHost.LocalHost.IPInformation.NetworkAdapter;
await listener.BindServiceNameAsync(ServiceNameForListener.Text, selectedAdapter);
rootPage.NotifyUser(
"Listening on adapter " + selectedAdapter.NetworkAdapterId,
NotifyType.StatusMessage);
}
}
catch (Exception exception)
{
CoreApplication.Properties.Remove("listener");
// 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);
}
}
/// <summary>
/// Creates a new UDP socket and starts advertising the AdvertisingMessage to the AdvertiserPort and AdvertiserGroupHost
/// </summary>
public override async Task<bool> StartAdvertisingAsync()
{
bool status = false;
if (AdvertiserSocket == null)
{
AdvertiserSocket = new DatagramSocket();
// Attach event handler and start listening on given port.
AdvertiserSocket.MessageReceived += MessageToConnectReceivedFromParticipantAsync;
await AdvertiserSocket.BindServiceNameAsync(AdvertiserPort);
// Start the timer, to send a message every X milliseconds.
_timer = new Timer(async state => await SendMessageAsync(), null, 0, AdvertiserInterval);
status = true;
}
return status;
}
private static async Task BindToSocketAndWriteQuery(DatagramSocket socket, byte[] bytes, CancellationToken cancellationToken)
{
#if !WINDOWS_PHONE
try
{
// Try to bind using port 5353 first
await socket.BindServiceNameAsync("5353", NetworkInformation.GetInternetConnectionProfile().NetworkAdapter)
.AsTask(cancellationToken)
.ConfigureAwait(false);
}
catch (Exception)
{
// If it fails, use the default
await socket.BindServiceNameAsync("", NetworkInformation.GetInternetConnectionProfile().NetworkAdapter)
.AsTask(cancellationToken)
.ConfigureAwait(false);
}
#else
await socket.BindServiceNameAsync("5353")
.AsTask(cancellationToken)
.ConfigureAwait(false);
#endif
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();
}
}
private async void StartListener_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(ServiceNameForListener.Text))
{
_rootPage.NotifyUser("Please provide a service name.", NotifyType.ErrorMessage);
return;
}
if (CoreApplication.Properties.ContainsKey("listener"))
{
_rootPage.NotifyUser(
"This step has already been executed. Please move to the next one.",
NotifyType.ErrorMessage);
return;
}
CoreApplication.Properties.Remove("serverAddress");
// サーバソケットの作成
var listener = new Windows.Networking.Sockets.DatagramSocket();
// メッセージを受信したときのハンドラ
listener.MessageReceived += MessageReceivedAsync;
if (!string.IsNullOrWhiteSpace(InboundBufferSize.Text))
{
if (!uint.TryParse(InboundBufferSize.Text, out var inboundBufferSize))
{
_rootPage.NotifyUser(
"Please provide a positive numeric Inbound buffer size.",
NotifyType.ErrorMessage);
return;
}
try
{
// 受信時のデータバッファサイズをセット
listener.Control.InboundBufferSizeInBytes = inboundBufferSize;
}
catch (ArgumentException)
{
_rootPage.NotifyUser("Please provide a valid Inbound buffer size.", NotifyType.ErrorMessage);
return;
}
}
// Address or Adapter binding
LocalHostItem selectedLocalHost = null;
if ((BindToAddress.IsChecked == true) || (BindToAdapter.IsChecked == true))
{
selectedLocalHost = (LocalHostItem)AdapterList.SelectedItem;
if (selectedLocalHost == null)
{
_rootPage.NotifyUser("Please select an address / adapter.", NotifyType.ErrorMessage);
return;
}
CoreApplication.Properties.Add("serverAddress", selectedLocalHost.LocalHost.CanonicalName);
}
// 作成したソケットをアプリに保存する
CoreApplication.Properties.Add("listener", listener);
// Listenの開始
try
{
if (BindToAny.IsChecked == true)
{
// コントロールに入力されたポートでListenする
await listener.BindServiceNameAsync(ServiceNameForListener.Text);
_rootPage.NotifyUser("Listening", NotifyType.StatusMessage);
}
else if (BindToAddress.IsChecked == true)
{
if (selectedLocalHost == null)
{
return;
}
await listener.BindEndpointAsync(selectedLocalHost.LocalHost, ServiceNameForListener.Text);
_rootPage.NotifyUser(
"Listening on addrress " + selectedLocalHost.LocalHost.CanonicalName,
NotifyType.StatusMessage);
}
else if (BindToAdapter.IsChecked == true)
{
if (selectedLocalHost == null)
{
return;
}
var selectedAdapter = selectedLocalHost.LocalHost.IPInformation.NetworkAdapter;
await listener.BindServiceNameAsync(ServiceNameForListener.Text, selectedAdapter);
_rootPage.NotifyUser(
"Listening on adapter " + selectedAdapter.NetworkAdapterId,
NotifyType.StatusMessage);
}
}
catch (Exception exception)
{
CoreApplication.Properties.Remove("listenner");
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
_rootPage.NotifyUser(
"Start listening failed with error: " + exception.Message,
NotifyType.ErrorMessage);
}
}
/// <summary>
/// Searches for an available devices of specified type.
/// </summary>
/// <param name="searchTarget">
/// The type of the devices to search for.
/// </param>
/// <param name="timeForResponse">
/// The time (in seconds) of a search.
/// </param>
/// <returns>
/// An observable collection which contains search results.
/// </returns>
public IObservable<SearchResponseMessage> Search(string searchTarget, int timeForResponse)
{
return Observable.Create<SearchResponseMessage>(async observer =>
{
var searchSocket = new DatagramSocket();
// Handling responses from found devices
searchSocket.MessageReceived += async (sender, args) =>
{
var dataReader = args.GetDataReader();
dataReader.InputStreamOptions = InputStreamOptions.Partial;
if (dataReader.UnconsumedBufferLength == 0)
{
await dataReader.LoadAsync(1024);
}
var message = dataReader.ReadString(dataReader.UnconsumedBufferLength);
try
{
var response = SearchResponseMessage.Create(message);
observer.OnNext(response);
}
catch (ArgumentException ex)
{
logger.Instance().Warning(ex, "The received M-Search response has been ignored.", "Message".As(message));
}
};
await searchSocket.BindServiceNameAsync("0");
searchSocket.JoinMulticastGroup(this.multicastHost);
var request = MSearchRequestFormattedString.F(searchTarget, timeForResponse);
var buffer = Encoding.UTF8.GetBytes(request).AsBuffer();
// Sending the search request to a multicast group
var outputStream = await searchSocket.GetOutputStreamAsync(this.multicastHost, MulticastPort.ToString());
await outputStream.WriteAsync(buffer);
await outputStream.WriteAsync(buffer);
// Stop listening for a devices when timeout for responses is expired
Observable.Timer(TimeSpan.FromSeconds(timeForResponse)).Subscribe(s =>
{
observer.OnCompleted();
searchSocket.Dispose();
});
logger.Instance().Debug("M-Search request has been sent. [multicastHost={0}, searchTarget={1}]".F(multicastHost.DisplayName, searchTarget));
return searchSocket.Dispose;
});
}
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 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;
}
