private async Task StartListeningAsyncUDP(int portNum)
{
listenerUDP.MessageReceived += ListenerUDP_MessageReceived;
await listenerUDP.StartListeningAsync(portNum);
ListenUdpLoop();
}
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 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);
}
public async void Listen(int listenPort)
{
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
// get the remote endpoint details and convert the received data into a string
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
string messageReceived = string.Format("{0} - {1}", from, data);
Console.WriteLine(messageReceived);
InvokeMessageReceived(args.RemoteAddress, int.Parse(args.RemotePort), messageReceived);
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, 5001);
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, int.Parse(args.RemotePort));
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, 5002);
};
// listen for udp traffic on listenPort
await receiver.StartListeningAsync(listenPort);
Console.WriteLine("Listening on " + listenPort);
}
protected override async void OnHandleIntent(Intent intent)
{
//UDP Receiver
var listenPort = 15000;
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
//Daten und Senderadresse auswerten
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
//Falls Link übermittelt
if (string.IsNullOrEmpty(data) == false)
{
//Starte MainActivity (mit erhaltener URI)
Intent i = new Intent(this, typeof(MainActivity));
i.SetData(Uri.Parse(data));
//i.AddFlags(ActivityFlags.NewTask);
this.StartActivity(i);
}
};
//Abhören am UDP Port starten
await receiver.StartListeningAsync(listenPort);
}
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 Task ReceiveMessage()
{
try
{
receiver.MessageReceived += async(sender, args) =>
{
// get the remote endpoint details and convert the received data into a string
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
Console.WriteLine("Received " + data);
if (data.IndexOf("Server received") > -1)
{
Console.WriteLine("Received echo " + data);
return;
}
string returnMsg = String.Format("Server received {0} - {1}", from, data);
var msgBytes = Encoding.UTF8.GetBytes(returnMsg);
await client.SendAsync(msgBytes);
Console.WriteLine("Sending: " + returnMsg);
EndPoint remoteEnd = new IPEndPoint(IPAddress.Parse(this.sendsTo), this.sendsOn);
_socket.SendTo(msgBytes, remoteEnd);
Console.WriteLine("Sent using clean socket: " + returnMsg);
await clientUnconnected.SendToAsync(msgBytes, this.sendsTo, int.Parse(args.RemotePort));
EndPoint remoteEndLocal = new IPEndPoint(IPAddress.Parse(this.sendsTo), int.Parse(args.RemotePort));
_socket.SendTo(msgBytes, remoteEndLocal);
Console.WriteLine("Sent using clean socket (local): " + returnMsg);
EndPoint remoteEndLocal2 = new IPEndPoint(IPAddress.Parse(args.RemoteAddress), int.Parse(args.RemotePort));
_socket.SendTo(msgBytes, remoteEndLocal2);
Console.WriteLine("Sent using clean socket (local): " + returnMsg);
};
Console.WriteLine("Listening on " + this.receivesOn);
await receiver.StartListeningAsync(0);
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
byte[] buffer = new byte[1024];
e.SetBuffer(buffer, 0, buffer.Length);
e.Completed += new EventHandler <SocketAsyncEventArgs>(IO_Completed);
_socket.ReceiveAsync(e);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private async Task StartListeningAsyncUDP(int portNum)
{
if (listenerUDP == null)
{
throw new InvalidOperationException("Cannot listen on UDP when in TCP only mode.");
}
listenerUDP.MessageReceived += ListenerUDP_MessageReceived;
await listenerUDP.StartListeningAsync(portNum);
ListenUdpLoop();
}
public static async void GetListOfLocalHosts(string ipAddr)
{
receiveSocket = new UdpSocketReceiver();
await receiveSocket.StartListeningAsync(RxPort);
await StartDiscovery(OnServerDiscovered, ipAddr);
// Wait until the control thread is done before proceeding.
// This keeps the inactivity timers from overlapping.
}
public async Task Init()
{
try
{
await receiver.StartListeningAsync(listenPort);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
}
}
private async Task ListenForBroadcast()
{
if (isReceiving)
{
return;
}
ReceiveLog.Text += "Now listening...\n";
Discoverable.IsEnabled = false;
await listener.StartListeningAsync(BROADCAST_PORT);
Discoverable.IsEnabled = true;
}
public async void StartUDPReceive()
{
await udpReceiver.StartListeningAsync(PORT);
udpReceiver.MessageReceived += (sender, args) =>
{
string data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
List <string> info = data.Split('*').ToList();
if (info[0] == "1")
{
ReceivedDiscoverReply(IPAddress.Parse(args.RemoteAddress), info.Skip(1).ToList());
}
};
}
public static async void Start()
{
udpReciever.MessageReceived += async(sender, args) =>
{
parseUdpMessage(args.RemoteAddress, args.ByteData);
};
try
{
await udpReciever.StartListeningAsync(Global.UdpPort);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
}
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 async void Connect()
{
try
{
if (UdpClient != null)
{
try
{
await UdpClient.StopListeningAsync();
UdpClient.Dispose();
}
catch (Exception ex)
{
if (IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
}
UdpClient = new UdpSocketReceiver();
UdpClient.MessageReceived += OnMessageReceived;
}
catch (SocketException ex)
{
if (IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
return;
}
}
await UdpClient.StartListeningAsync(LocalEndpoint.Port);
try
{
ConnectRequest();
}
catch (Exception ex)
{
if (IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
}
public async Task StartAsync()
{
List <CommsInterface> interfaces = await CommsInterface.GetAllInterfacesAsync();
this.receiver = new UdpSocketReceiver();
receiver.MessageReceived += this.ReceiverOnMessageReceived;
try {
// listen for udp traffic on listenPort
await receiver.StartListeningAsync(this.listenPort);
this.log($"listening on port {this.listenPort}");
}
catch (Exception e) {
this.log($"failed to listen on port {this.listenPort}.{Environment.NewLine}{e}");
}
}
public async Task <byte[]> Receive(IPEndPoint remoteHost)
{
var receiver = new UdpSocketReceiver();
byte[] data = new byte[1];
receiver.MessageReceived += (sender, args) =>
{
// get the remote endpoint details and convert the received data into a string
data = args.ByteData;
};
await receiver.StartListeningAsync(remoteHost.Port);
System.Console.WriteLine(System.DateTime.Now.ToString() + "<<< " + remoteHost);
System.Console.WriteLine(FormatterHelper.Deserialize(data).ToString());
System.Console.WriteLine();
return(data);
}
public Listener()
{
Console.WriteLine("Starting Server");
var udpReceived = new UdpSocketReceiver();
udpReceived.StartListeningAsync(8888);
udpReceived.MessageReceived += (sender, args) =>
{
System.Console.WriteLine($"Remote adrres: {args.RemoteAddress}");
System.Console.WriteLine($"Remote port: {args.RemotePort}");
var str = System.Text.Encoding.UTF8.GetString(args.ByteData);
System.Console.WriteLine($"Messsage: {str}");
MainWindow._current.AddMessage(str, true);
MainWindow._current.SentenceAnalyzer.Analyze(str);
};
}
public async void StartUDPReceive()
{
await udpReceiver.StartListeningAsync(PORTR);
udpReceiver.MessageReceived += (sender, args) =>
{
string data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
List <string> info = data.Split('*').ToList();
switch (info[0])
{
case "0":
break;
case "1":
ReceivedDiscoverReply(IPAddress.Parse(args.RemoteAddress), info /*.Skip(1).ToList()*/);
break;
case "3":
ReceivedBindReply(IPAddress.Parse(args.RemoteAddress), info.Skip(1).ToList());
break;
case "5":
ReceivedBindDroppedAcknowledge();
break;
case "7":
break;
case "9":
break;
case "a":
KeepAliveReceived();
break;
default:
ReceivedInvalidUDP(info);
break;
}
;
};
}
async protected override void OnStart()
{
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
var data = System.Text.Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
if (data.StartsWith(MAPLE_HOSTNAME, System.StringComparison.CurrentCultureIgnoreCase))
{
var address = data.Split(new char[] { '=' })[1];
if (string.Compare(address, DehydratorHostAddress) != 0)
{
DehydratorHostAddress = address;
Debug.WriteLine("HostAddress updated: " + DehydratorHostAddress);
}
}
};
await receiver.StartListeningAsync(MAPLE_SERVER_BROADCAST_PORT);
}
private static async void UdpListener()
{
var udpReceived = new UdpSocketReceiver();
await udpReceived.StartListeningAsync(1234, allowMultipleBindToSamePort : true);
var udpMessageSubscriber = udpReceived.ObservableMessages.Subscribe(
msg =>
{
System.Console.WriteLine($"Remote adrres: {msg.RemoteAddress}");
System.Console.WriteLine($"Remote port: {msg.RemotePort}");
var str = System.Text.Encoding.UTF8.GetString(msg.ByteData);
System.Console.WriteLine($"Messsage: {str}");
},
ex =>
{
// Exceptions received here;
});
udpMessageSubscriber.Dispose();
}
private async Task Pair()
{
await Task.Delay(4000);
ProgressText = $"Start pairing";
OnPropertyChanged("ProgressText");
// give some time to connect
await Task.Delay(10000);
var currentIp = wifiManager.GetCurrentIp();
ProgressText = $"Current Ip address is {currentIp}";
OnPropertyChanged("ProgressText");
var msg = $"IOTC:{currentIp}:5000";
var msgBytes = Encoding.UTF8.GetBytes(msg);
udpReceiver.MessageReceived += StartSendCredentials;
await udpReceiver.StartListeningAsync(5000);
int retry = 0;
try
{
while (retry < 5)
{
await udpClient.SendToAsync(msgBytes, address, port);
await Task.Delay(500);
retry++;
}
}
catch (SocketException ex)
{
ProgressText = $"Error Sending pairing message {ex.Message}";
OnPropertyChanged("ProgressText");
}
}
public async Task WaitForCompanion()
{
Serializer = new ProtobufNetworkSerializer();
var tcs = new TaskCompletionSource <bool>();
listener = new UdpSocketReceiver();
listener.MessageReceived += (s, e) =>
{
remoteAddress = e.RemoteAddress;
remotePort = e.RemotePort;
var dto = Serializer.Deserialize <BaseDto>(e.ByteData);
var handshakeDto = dto as PingDto;
if (handshakeDto != null)
{
var msg = handshakeDto.Message;
}
tcs.TrySetResult(true);
};
await listener.StartListeningAsync(Port);
await tcs.Task;
}
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)
}
};
}
private async void iniReceiver()
{
await _receiver.StartListeningAsync(_port);
}
public void Start(int port)
{
receiver.StartListeningAsync(port);
}
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()
});
}
public PacketsPage()
{
InitializeComponent();
tcpPort = SettingsPage.TCPPort;
udpPort = SettingsPage.UDPPort;
tcpServer = new TcpSocketListener();
udpServer = new UdpSocketReceiver();
tcpServer.ConnectionReceived += TcpConnection;
udpServer.MessageReceived += UdpConnection;
Task.Run(async() =>
{
await tcpServer.StartListeningAsync(tcpPort);
await udpServer.StartListeningAsync(udpPort);
SettingsPage.TCPPort = tcpServer.LocalPort;
MessagingCenter.Send(this, Events.BOUND_PORTS_CHANGED, 0);
});
//udpServer.StartListeningAsync(udpPort);
/*
+= async (sender, args) =>
* {
* var client = args.SocketClient;
*
* var bytesRead = -1;
* var buf = new byte[1];
*
* while (bytesRead != 0)
* {
* bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1);
* //if (bytesRead > 0)
* // Debug.Write(buf[0]);
* }
* };
*/
_connection = DependencyService.Get <ISQLiteDb>().GetConnection();
/*
* var demopackets = Packet.GetDemoPackets();
* for (int i = 0; i < demopackets.Count(); i++) {
* _thepackets.Add(demopackets[i]);
* }
* packetListView.ItemsSource = _thepackets;
*/
tcp = new TcpSocketClient();
udp = new UdpSocketClient();
thepacket = new Packet();
MessagingCenter.Subscribe <LoginPage, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsync);
MessagingCenter.Subscribe <ImportCloud, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsyncIC);
MessagingCenter.Subscribe <PacketEditPage, Packet>(this, Events.PACKET_MODIFIED, OnPacketModified);
}