public static async System.Threading.Tasks.Task <byte[]> Send(string host, int port, byte[] request)
{
var listenPort = 56800;
var receiver = new UdpSocketReceiver();
TaskCompletionSource <byte[]> responseReceived = new TaskCompletionSource <byte[]>();
receiver.MessageReceived += (sender, args) =>
{
responseReceived.SetResult(args.ByteData);
receiver.StopListeningAsync();
};
//var client = new UdpSocketClient();
await receiver.StartListeningAsync(listenPort);
await receiver.SendToAsync(request, host, port);
// listen for udp traffic on listenPort
await responseReceived.Task;
return(responseReceived.Task.Result);
}
// Connect to the time server and update system time
private async Task StartAsync()
{
if (isBusy == false)
{
isBusy = true;
Debug.WriteLine($"Syncing Timer with SNTP {TimeServer}");
// Initialize data structure
Initialize();
var tcs = new TaskCompletionSource <byte[]>();
using (var socket = new UdpSocketReceiver())
{
socket.MessageReceived += async(sender, args) =>
{
await socket.StopListeningAsync();
tcs.SetResult(args.ByteData);
};
await socket.StartListeningAsync();
await socket.SendToAsync(SNTPData, TimeServer, 123);
SNTPData = await tcs.Task;
}
DestinationTimestamp = DateTime.Now;
SetTime();
isBusy = false;
}
}
protected override async void OnAppearing()
{
Debug.WriteLine("OnAppearing: PacketsPage.xaml.cs");
// In a multi-page app, everytime we come back to this page, OnAppearing
// method is called, but we want to load the data only the first time
// this page is loaded. In other words, when we go to ContactDetailPage
// and come back, we don't want to reload the data. The data is already
// there. We can control this using a switch: isDataLoaded.
if (_isDataLoaded)
{
return;
}
_isDataLoaded = true;
// I've extracted the logic for loading data into LoadData method.
// Now the code in OnAppearing method looks a lot cleaner. The
// purpose is very explicit. If data is loaded, return, otherwise,
// load data. Details of loading the data is delegated to LoadData
// method.
await LoadData();
base.OnAppearing();
//app needs to turn off tcp server.
MessagingCenter.Subscribe <App>(this, Events.APP_RESUME, async app => {
//Do something
Debug.WriteLine("APP_RESUME: PacketsPage.xaml.cs");
await tcpServer.StartListeningAsync(tcpPort);
await udpServer.StartListeningAsync(udpPort);
});
MessagingCenter.Subscribe <App>(this, Events.APP_SLEEP, app => {
//Do something
Debug.WriteLine("APP_SLEEP: PacketsPage.xaml.cs");
tcpServer.StopListeningAsync();
udpServer.StopListeningAsync();
});
MessagingCenter.Subscribe <App>(this, Events.APP_DISAPPEAR, app => {
//Do something
Debug.WriteLine("APP_DISAPPEAR: PacketsPage.xaml.cs");
tcpServer.StopListeningAsync();
udpServer.StopListeningAsync();
});
}
public static async Task <DateTime> GetNetworkTimeAsync()
{
Debug.WriteLine("Entro in GetNTP " + DateTime.Now);
//default Windows time server
const string ntpServer = "time.windows.com";
//const string ntpServer = "pool.ntp.org";
//const string ntpServer = "time.nist.gov";
// NTP message size - 16 bytes of the digest (RFC 2030)
var ntpData = new byte[48];
//Setting the Leap Indicator, Version Number and Mode values
ntpData[0] = 0x1B; //LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)
var tcs = new TaskCompletionSource <byte[]>();
using (var socket = new UdpSocketReceiver())
{
socket.MessageReceived += async(sender, args) =>
{
await socket.StopListeningAsync();
tcs.SetResult(args.ByteData);
};
Debug.WriteLine("StartListening " + DateTime.Now);
await socket.StartListeningAsync(); // any free port >1000 will do
Debug.WriteLine("SendTo " + DateTime.Now);
await socket.SendToAsync(ntpData, ntpServer, 123).ContinueWith(_ => Task.FromResult(true)).TimeoutAfter(TimeSpan.FromSeconds(3)); //.TimeoutAfter(TimeSpan.FromSeconds(3));
Debug.WriteLine("SendTo conclusa");
ntpData = await tcs.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
//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);
var milliseconds = (intPart * 1000) + ((fractPart * 1000) / 0x100000000L);
//**UTC** time
var networkDateTime = (new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddMilliseconds((long)milliseconds);
Debug.WriteLine("Esco da GetNTP " + DateTime.Now + " - " + networkDateTime + " - LOCALTIME: " + networkDateTime.ToLocalTime() + " - UTC: " + networkDateTime.ToUniversalTime());
return(networkDateTime.ToLocalTime());
}
private static void StopDiscovery()
{
if (null != transmitSocket)
{
transmitSocket.DisconnectAsync();
}
if (null != receiveSocket)
{
receiveSocket.StopListeningAsync();
}
}
private async Task CancelBroadcast()
{
if (!isBroadcasting)
{
return;
}
RefreshDevices.IsEnabled = false;
RefreshDevices.Text = "Refresh Devices";
SendLog.Text += "Stopping broadcast...\n";
sendCancelSource.Cancel();
await broadcaster.StopListeningAsync();
isBroadcasting = false;
RefreshDevices.IsEnabled = true;
}
private void InitView()
{
Content = new StackLayout
{
Padding = new Thickness(0, Device.OnPlatform(20, 0, 0), 0, 0),
Children =
{
new ListenerBindView(11011, this)
{
StartListeningTapped = async i =>
{
await _receiver.StartListeningAsync(i, Global.DefaultCommsInterface);
return(true);
},
StopListeningTapped = async() =>
{
await _receiver.StopListeningAsync();
}
},
new MessagesView(_messagesObs, false)
}
};
}
public void Stop()
{
receiver.StopListeningAsync();
}
async public static Task <ServerList> BrowseForNoahServers(string friendlyName, string ipAddress)
{
var client = new UdpSocketClient();
var receiver = new UdpSocketReceiver();
try
{
var address = GetIpAddressForBroadcast(ipAddress);
//// convert our greeting message into a byte array
string clientGUID = "{B0BE0E7D-F70B-40BE-91AB-14125863B0B7}";
System.Text.Encoding enc = System.Text.Encoding.UTF8;
byte[] sendBuffer = enc.GetBytes(clientGUID);
receiver.MessageReceived += (sender, args) =>
{
try
{
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var fromIp = args.RemoteAddress;
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
try
{
LocalRemoteHostInfo payload =
Helpers.Deserialize <LocalRemoteHostInfo>(Encoding.UTF8.GetString(args.ByteData, 0,
args.ByteData.Length));
string guid = payload.LocalNoahServerGuid;
if (guid.Equals("{5FE140D5-1D3F-4E46-8892-15FA89DAE9F4}"))
{
bool duplicate = false;
foreach (ServerData servData in ServerCollection)
{
if (servData.ServerIp.Equals(fromIp))
{
duplicate = true; //The adress is allready in the list
break;
}
}
if (duplicate == false) //No need to list Gatteway IP
{
if (string.IsNullOrEmpty(friendlyName))
{
ServerCollection.Add(new ServerData
{
ServerName = payload.HostName,
FriendlyName = payload.FriendlyName,
ServerIp = payload.LocalHostIpAddress,
RemoteHostId = payload.RemoteHostId
});
}
else
{
if (friendlyName == payload.FriendlyName)
{
receiver.StopListeningAsync();
ServerCollection.Add(new ServerData
{
ServerName = payload.HostName,
FriendlyName = payload.FriendlyName,
ServerIp = payload.LocalHostIpAddress,
RemoteHostId = payload.RemoteHostId
});
//client.Dispose();
//receiver.Dispose();
waitTime = false;
}
}
}
}
}
catch { }
}
catch { }
};
try
{
receiver.StartListeningAsync(listenPort);
}
catch (Exception e)
{
}
client.ConnectAsync(address, port);
client.SendAsync(sendBuffer);
DateTime now = DateTime.Now;
DateTime stop = now + new TimeSpan(0, 0, 0, 5);
while (waitTime)
{
if (DateTime.Now > stop)
{
waitTime = false;
}
}
}
catch (Exception e)
{
Log.ErrorFormat("Himsa.Noah.MobileAccessLayer.NoahServerUdpBrowser::BrowseForNoahServers(): {0}", e);
throw;
}
finally
{
client.DisconnectAsync();
receiver.StopListeningAsync();
receiver.Dispose();
}
return(new ServerList
{
Servers = ServerCollection.ToArray()
});
}
private void BroadcastReceived(object sender, UdpSocketMessageReceivedEventArgs args)
{
if (isReceiving)
{
Task.WaitAny(listener.StopListeningAsync());
return;
}
if (args.RemoteAddress.Equals(address.ToString()))
{
return;
}
var ClientRequest = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
SharingResult Result;
try
{
Result = JsonConvert.DeserializeObject <SharingResult>(ClientRequest);
}
catch (Exception ex)
{
Device.BeginInvokeOnMainThread(() =>
{
ReceiveLog.Text += "Error when deserializing the response.\n";
});
return;
}
if (Result.Type == ValueType.RequestIP && Result.Value.Equals("GIMMEHYOURADDRESS"))
{
Device.BeginInvokeOnMainThread(() =>
{
ReceiveLog.Text += $"Received broadcast from {args.RemoteAddress}\n";
});
var Response = JsonConvert.SerializeObject(new SharingResult()
{
Name = DeviceInfo.Name, Type = ValueType.IPResponse, Value = address.ToString(), IsDiscoverable = isDiscoverable
});
var ResponseData = Encoding.UTF8.GetBytes(Response);
if (Result.IsDiscoverable)
{
IPAddress ip;
if (IPAddress.TryParse(args.RemoteAddress, out ip))
{
if (!discoveredDevices.Any(item => item.Address.ToString().Equals(ip.ToString())))
{
Device.BeginInvokeOnMainThread(() =>
{
ReceiveLog.Text += $"Discovered device \"{Result.Name}\" ({ip.ToString()})\n";
});
discoveredDevices.Add(new DeviceDetails()
{
Name = Result.Name, Address = ip
});
}
}
}
Task.WaitAny(listener.SendToAsync(ResponseData, args.RemoteAddress, BROADCAST_PORT));
}
}