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);
}
private async Task SendBroadcast()
{
if (isSending || isBroadcasting)
{
return; // don't want to keep sending broadcast when sending files
}
isBroadcasting = true;
RefreshDevices.IsEnabled = false;
sendCancelSource = new CancellationTokenSource();
discoveredDevices.Clear();
RefreshDevices.Text = "Stop Refresh";
SendLog.Text += "Now sending...\n";
// convert our greeting message into a byte array
var Response = JsonConvert.SerializeObject(new SharingResult()
{
Name = DeviceInfo.Name, Type = ValueType.RequestIP, Value = "GIMMEHYOURADDRESS", IsDiscoverable = isDiscoverable
});
var msgBytes = Encoding.UTF8.GetBytes(Response);
// send to address:port,
// no guarantee that anyone is there
// or that the message is delivered.
await broadcaster.StartListeningAsync(BROADCAST_PORT);
RefreshDevices.IsEnabled = true;
await PeriodicTask.RunAsync(broadcaster.SendToAsync(msgBytes, broadcast.ToString(), BROADCAST_PORT), TimeSpan.FromSeconds(2), sendCancelSource.Token);
}
// 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;
}
}
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());
}
public async void Send(BaseDto dto)
{
try
{
await listener.SendToAsync(Serializer.Serialize(dto), remoteAddress, int.Parse(remotePort));
}
catch (Exception exc)
{
//show error?
}
}
public static async Task <DnsServer> Create(string ip, int port, IRecordResolver recordResolver, IAuthority areWeAuthority, IExceptionHandler onError)
{
var networkInterface = Network.Interfaces.FirstOrDefault(x => x.IpAddress == ip);
var udpReceiver = new UdpSocketReceiver();
var observerUdpReceiver = await udpReceiver.ObservableUnicastListener(
port : port,
communicationInterface : networkInterface,
allowMultipleBindToSamePort : false);
var subscriberUpdReceiver = observerUdpReceiver.Subscribe(
async udpMsg =>
{
var req = Reader.ReadRequest(new MemoryStream(udpMsg.ByteData));
var response = new Response(req);
foreach (var q in req)
{
var record = recordResolver.Resolve(q.Class, q.Type, q.Name);
if (record == null)
{
continue;
}
if (areWeAuthority?.AreWeAuthority(q.Name) ?? false)
{
response.Authorities.Add(record);
}
else
{
response.Answers.Add(record);
}
}
await udpReceiver.SendToAsync(Writer.Serialize(response), udpMsg.RemoteAddress, int.Parse(udpMsg.RemotePort));
},
x => onError?.OnError(x));
return(new UDPServer
{
udpReceiver = udpReceiver,
observerUdpReceiver = observerUdpReceiver,
subscriberUpdReceiver = subscriberUpdReceiver,
RecordResolver = recordResolver
});
}
public async void doSend(Packet sendpacket)
{
Debug.WriteLine($"PP:doSend {sendpacket.method} {sendpacket.toip} {sendpacket.toport} {sendpacket.ascii}");
// byte[] bytesToSend = System.Text.Encoding.UTF8.GetBytes(sendpacket.ascii);
byte[] bytesToSend = sendpacket.getByteArray();
try
{
sendpacket.error = "";
await tcp.DisconnectAsync();
if (sendpacket.isTCP())
{
await tcp.ConnectAsync(sendpacket.toip, sendpacket.toport);
await tcp.WriteStream.WriteAsync(bytesToSend, 0, bytesToSend.Length);
await tcp.DisconnectAsync();
/*
* // wait a little before reading
* var bytesRecv = new byte[20];
* //tcp.ReadStream.ReadTimeout = 200;
* //not async, so it can time out.
* await Task.Delay(TimeSpan.FromMilliseconds(00));
* if (tcp.ReadStream.Length > 0)
* {
* int bytesRead = await tcp.ReadStream.ReadAsync(bytesRecv, 0, 20);
* if (bytesRead > 0)
* {
* Packet receivepkt = new Packet();
* receivepkt.toip = sendpacket.fromip;
* receivepkt.fromip = sendpacket.toip;
* receivepkt.fromport = sendpacket.toport;
* Array.Resize(ref bytesRecv, bytesRead);
* receivepkt.hex = Packet.byteArrayToHex(bytesRecv);
* MessagingCenter.Send(this, Events.NEW_TRAFFIC_PACKET, receivepkt);
* }
*
* }
*/
}
if (sendpacket.isUDP())
{
await udpServer.SendToAsync(bytesToSend, sendpacket.toip, sendpacket.toport);
}
}
catch (Exception eSend)
{
sendpacket.error = "Error: " + eSend.Message;
Debug.WriteLine("PP:Exception : " + eSend.Message);
}
Debug.WriteLine("PP:Before Message");
MessagingCenter.Send(this, Events.NEW_TRAFFIC_PACKET, sendpacket);
Debug.WriteLine("PP:After Message");
Debug.WriteLine("PP:Finished");
}
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));
}
}
