/// <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);
}
}
}
