public static void ServerDatagramSocket_MessageReceived(
Windows.Networking.Sockets.DatagramSocket sender,
Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
string respond;
using (DataReader dataReader = args.GetDataReader())
{
respond = dataReader.ReadString(dataReader.UnconsumedBufferLength).Trim();
}
StatusResponse = respond;
}
public static void ClientDatagramSocket_MessageReceived(
Windows.Networking.Sockets.DatagramSocket sender,
Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
string response;
using (DataReader dataReader = args.GetDataReader())
{
byte[] buffer = new byte[dataReader.UnconsumedBufferLength];
dataReader.ReadBytes(buffer);
StringBuilder builder = new StringBuilder();
foreach (var item in buffer)
{
builder.Append((char)item);
}
response = builder.ToString();
}
Debug.WriteLine("COMMAND RESPONSE:" + response);
ReportMsg("COMMAND RESPONSE:" + response);
CommandResponse = response;
//iserror = (response != "ok");
//sender.Dispose();
}
private void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
using (var reader = args.GetDataReader())
{
var buf = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(buf);
MessageReceived?.Invoke(new DatagramSocketMessage(args.RemoteAddress.CanonicalName, buf));
}
}
private void _Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
using (var reader = args.GetDataReader())
{
var data = new ReceivedUdpData()
{
ReceivedBytes = Convert.ToInt32(reader.UnconsumedBufferLength),
ReceivedFrom = new UdpEndPoint()
{
IPAddress = args.RemoteAddress.RawName,
Port = Convert.ToInt32(args.RemotePort)
}
};
data.Buffer = new byte[data.ReceivedBytes];
reader.ReadBytes(data.Buffer);
_ReceivedData.Enqueue(data);
_DataAvailableSignal.Set();
}
}
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();
//Create a new socket to send the same message back to the UDP echo client.
}
private void ServerDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
Stream streamIn = args.GetDataStream().AsStreamForRead();
MemoryStream ms = ToMemoryStream(streamIn);
byte[] data = ms.ToArray();
switch (ReceivingStatus)
{
case AWAITING_IMAGE:
if (data.Length == 3)
{
StartReceivingImage(data);
}
break;
default:
if (data.Length == 0)
{
// Handle image here
serverDatagramSocket.MessageReceived -= ServerDatagramSocket_MessageReceived;
ReceivingStatus = AWAITING_IMAGE;
byte[] processingBuffer = ImageBuffer;
ImageBuffer = null;
DisplayImage(processingBuffer);
ImgCount++;
// showImage = false;
Debug.WriteLine(ImgCount);
}
// It's only possible for start packets to be of size 3 (others must be >= 4)
else if (data.Length == 3)
{
StartReceivingImage(data);
}
else
{
int ind = data[0];
ind |= ((data[1] & 0xff) << 8);
ind |= ((data[2] & 0xff) << 16);
for (int i = 0; i < data.Length - 3; ++i)
{
ImageBuffer[(ind * PACKET_SIZE) + i] = data[i + 3];
}
}
break;
}
}
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 Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => listbox_Logger.Items.Add(request));
// Echo the request back as the response.
using (Stream outputStream = (await sender.GetOutputStreamAsync(args.RemoteAddress, "1337")).AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
//await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => this.listbox_Logger.Items.Add(string.Format("server sent back the response: \"{0}\"", request)));
sender.Dispose();
// await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => this.listbox_Logger.Items.Add("server closed its socket"));
}
/// <summary>
/// Event hander when receiving response from the ntp server.
/// </summary>
/// <param name="socket">The udp socket object which triggered this event </param>
/// <param name="eventArguments">event information</param>
void OnNTPTimeReceived(Windows.Networking.Sockets.DatagramSocket socket, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs eventArguments)
{
int currentRTT = (int)ntpResponseMonitor.ElapsedMilliseconds;
Debug.WriteLine($"NtpSync: current RTT {currentRTT}");
ntpResponseMonitor.Stop();
if (currentNtpQueryCount < MaxNtpRTTProbeQuery)
{
//we only trace 'min' RTT within the RTT probe attempts
if (minNtpRTT == -1 || minNtpRTT > currentRTT)
{
minNtpRTT = currentRTT;
if (minNtpRTT == 0)
{
minNtpRTT = 1; //in case we got response so fast, consider it to be 1ms.
}
}
averageNtpRTT = (averageNtpRTT * (currentNtpQueryCount - 1) + currentRTT) / currentNtpQueryCount;
if (averageNtpRTT < 1)
{
averageNtpRTT = 1;
}
RunOnUiThread(() =>
{
ntpQueryTimer.Stop();
ntpRTTIntervalTimer.Start();
});
return;
}
//if currentRTT is good enough, e.g.: closer to minRTT, then, we don't have to continue to query.
if (currentRTT > (averageNtpRTT + minNtpRTT) / 2)
{
RunOnUiThread(() =>
{
ntpQueryTimer.Stop();
ntpRTTIntervalTimer.Start();
});
return;
}
byte[] ntpData = new byte[48];
eventArguments.GetDataReader().ReadBytes(ntpData);
//Offset to get to the "Transmit Timestamp" field (time at which the reply
//departed the server for the client, in 64-bit timestamp format."
const byte serverReplyTime = 40;
//Get the seconds part
ulong intPart = BitConverter.ToUInt32(ntpData, serverReplyTime);
//Get the seconds fraction
ulong fractPart = BitConverter.ToUInt32(ntpData, serverReplyTime + 4);
//Convert From big-endian to little-endian
intPart = SwapEndianness(intPart);
fractPart = SwapEndianness(fractPart);
ulong milliseconds = (intPart * 1000) + ((fractPart * 1000) / 0x100000000L);
RunOnUiThread(() =>
{
OnNTPTimeAvailable?.Invoke((long)milliseconds + currentRTT / 2);
});
socket.Dispose();
ReportNtpSyncStatus(true, currentRTT);
}
private void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
uint dataLength = args.GetDataReader().UnconsumedBufferLength;
byte[] result = new byte[dataLength];
args.GetDataReader().ReadBytes(result);
SupportClass.PacketSupport packet = new SupportClass.PacketSupport(result, result.Length, new System.Net.IPEndPoint(System.Net.IPAddress.Parse(args.RemoteAddress.CanonicalName), int.Parse(args.RemotePort)));
try
{
if (Enclosing_Instance.localHost.ShouldIgnorePacket(packet))
{
return;
}
DNSIncoming msg = new DNSIncoming(packet);
logger.Debug("SocketListener.run() JmDNS in:" + msg.Print(true));
lock (Enclosing_Instance.IOLock)
{
if (msg.Query)
{
if (packet.Port != DNSConstants.MDNS_PORT)
{
Enclosing_Instance.HandleQuery(msg, packet.Address, packet.Port);
}
Enclosing_Instance.HandleQuery(msg, Enclosing_Instance.Group, DNSConstants.MDNS_PORT);
}
else
{
Enclosing_Instance.HandleResponse(msg);
}
}
}
catch (IOException e)
{
logger.Warn("run() exception ", e);
}
}
private async void ClientDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
string response;
using (DataReader dataReader = args.GetDataReader())
{
response = dataReader.ReadString(dataReader.UnconsumedBufferLength).Trim();
}
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => this.clientListBox.Items.Add(string.Format("client received the response: \"{0}\"", response)));
sender.Dispose();
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => this.clientListBox.Items.Add("client closed its socket"));
}
private void ClientDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
string response;
using (DataReader dataReader = args.GetDataReader())
{
response = dataReader.ReadString(dataReader.UnconsumedBufferLength).Trim();
}
sender.Dispose();
}
private async void Socket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs e)
{
Stream streamIn = e.GetDataStream().AsStreamForRead();
StreamReader streamReader = new StreamReader(streamIn);
string message = await streamReader.ReadLineAsync();
string[] tokens = message.Split(',');
// Handle Message
if (message[0] == 't' && tokens.Length == 12)
{
string percentString =
"0 : " + tokens[2] + "\n" +
"1 : " + tokens[3] + "\n" +
"2 : " + tokens[4] + "\n" +
"3 : " + tokens[5] + "\n" +
"4 : " + tokens[6] + "\n" +
"5 : " + tokens[7] + "\n" +
"6 : " + tokens[8] + "\n" +
"7 : " + tokens[9] + "\n" +
"8 : " + tokens[10] + "\n" +
"9 : " + tokens[11] + "\n";
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
//UI code here
resultText.Text = tokens[1];
percentText.Text = percentString;
});
}
}
private async void MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
this.writer = await this.client.GetOutputStreamAsync(args.RemoteAddress, args.RemotePort);
}
private void ServerDatagramSocket_MessageReceived(Windows.Networking.Sockets.DatagramSocket sender, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)
{
Stream streamIn = args.GetDataStream().AsStreamForRead();
MemoryStream ms = ToMemoryStream(streamIn);
byte[] data = ms.ToArray();
switch (ReceivingStatus)
{
case AWAITING_IMAGE:
if (data.Length == START_PACKET_SIZE)
{
StartReceivingImage(data);
}
break;
default:
if (data.Length == 0)
{
// Handle image here
byte[] processingBuffer = ImageBuffer;
ImageBuffer = null;
int imageType = ReceivingStatus;
ReceivingStatus = AWAITING_IMAGE;
// TODO: Launch DisplayImage in a new thread
DisplayImage(processingBuffer, imageType);
}
// It's only possible for start packets to be of size 3 (others must be >= 4)
else if (data.Length == START_PACKET_SIZE)
{
StartReceivingImage(data);
}
else
{
int ind = data[0];
ind |= ((data[1] & 0xff) << 8);
ind |= ((data[2] & 0xff) << 16);
for (int i = 0; i < data.Length - NORMAL_PACKET_INDEX_BYTES; ++i)
{
ImageBuffer[(ind * PACKET_SIZE) + i] = data[i + NORMAL_PACKET_INDEX_BYTES];
}
}
break;
}
}
