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