private static async Task ReaderAsync(int port, string groupAddress)
{
using (var client = new UdpClient(port))
{
if (groupAddress != null)
{
client.JoinMulticastGroup(IPAddress.Parse(groupAddress));
WriteLine($"joining the multicast group {IPAddress.Parse(groupAddress)}");
}
bool completed = false;
do
{
WriteLine("starting the receiver");
UdpReceiveResult result = await client.ReceiveAsync();
byte[] datagram = result.Buffer;
string received = Encoding.UTF8.GetString(datagram);
WriteLine($"received {received}");
if (received == "bye")
{
completed = true;
}
} while (!completed);
WriteLine("receiver closing");
if (groupAddress != null)
{
client.DropMulticastGroup(IPAddress.Parse(groupAddress));
}
}
}
/// <summary>
/// 向客户端异步发送文件
/// </summary>
/// <param name="ip"></param>
/// <param name="port"></param>
/// <param name="filePath"></param>
public async Task SendToClientFileAsync(string ip, int port, string filePath, Message msg)
{
// 新建 Udp 用于发送文件
var sendClient = new UdpClient();
try
{
FileInfo fileInfo = new FileInfo(filePath);
msg.Type = MessageEnum.FILE; // 设置发送文件标识
msg.FileLength = fileInfo.Length;
msg.FileName = Regex.Match(filePath, @"\\([^\\]+\.[^\\]+)").Groups[1].Value; // 获取文件名
byte[] datagram = Encoding.Unicode.GetBytes(JsonConvert.SerializeObject(msg));
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(ip), port);
/*
* 向‘原’远程客户端发送请求传送文件的请求,
* 接收‘新’远程客户端的响应,获取传送文件的端口
*
* 注：原远程客户端用于发送消息，新远程客户端用于发送文件
*/
await sendClient.SendAsync(datagram, datagram.Length, endPoint);
//IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
UdpReceiveResult result = await sendClient.ReceiveAsync().ConfigureAwait(false); // 阻塞直到接收到远程客户端的响应
/*
* 开始发送文件
*/
byte[] buffer = new byte[MAXSIZE];
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 1, true))
{
int percent = 0;
int count = 0;
while ((count = await fs.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
{
//await Task.Delay(10);
await sendClient.SendAsync(buffer, count, result.RemoteEndPoint);
if (Client.SendFileProgressNotify != null)
{
Client.SendFileProgressNotify(String.Format("{0:F2}%", (percent += count) / msg.FileLength * 100));
}
}
sendClient.Close();
}
}
catch (Exception e)
{
Log.Write(e.Message);
}
}
public void TestUDPPacket()
{
SharpNet.OnReceiveUDPPacketHandler Handler = async(UDPPacket Packet) =>
{
if (Packet.DestPort == remotePort)
{
UDPPacket echo = new UDPPacket(new byte[] { 1, 2, 3, 4, 5 });
echo.SourceIP = Packet.DestIP;
echo.DestIP = Packet.SourceIP;
echo.SourcePort = Packet.DestPort;
echo.DestPort = Packet.SourcePort;
await net.SendIPPacketAsync(echo);
}
};
net.OnReceiveUDPPacket += Handler;
CancellationTokenSource cts = new CancellationTokenSource();
int tx = 0;
int rx = 0;
Task.Run(() =>
{
while (true)
{
//byte[] data = client.Receive(ref remote);
byte[] data = client.ReceiveAsync().Result.Buffer;
foreach (var d in data)
{
Trace.Write(d);
}
rx++;
}
}, cts.Token);
Task.Run(() =>
{
while (true)
{
client.Send(new byte[] { 1, 2, 3, 4 }, 4, remote);
tx++;
Task.Delay(500).Wait();
}
}, cts.Token);
Task.Delay(5000).Wait();
cts.Cancel();
net.OnReceiveUDPPacket -= Handler;
Assert.IsTrue((rx == tx) && (rx != 0), "Send echo back received number does not match");
}
private void Run()
{
Task.Run(async() =>
{
client.Client.Bind(new IPEndPoint(IPAddress.Any, 0));
_tcs.SetResult(true);
using (client)
{
while (_isRunning)
{
try
{
var result = await client.ReceiveAsync();
lastActivity = DateTime.UtcNow;
var sent = await _server.SendAsync(result.Buffer, result.Buffer.Length, _clientEndpoint);
Console.WriteLine($"{sent} bytes sent from a return message of {result.Buffer.Length} bytes from {_remoteServer} to {_clientEndpoint}");
}
catch (Exception ex)
{
Console.WriteLine($"An exception occurred while recieving a server datagram : {ex}");
}
}
}
});
}
private async Task ReceiveText()
{
var remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
while (true)
{
try
{
//var buffer = _receiveClient.Receive(ref remoteEndPoint);
var buffer = await _receiveClient.ReceiveAsync();
if (buffer.Buffer.Length > 0)
{
string message = Encoding.ASCII.GetString(buffer.Buffer);
Dispatcher.Invoke(() => { TbReceiveContext.Text += message + Environment.NewLine; });
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
Thread.Sleep(1000);
}
}
}
public async Task <Edison.Plugin.Common.Net.UdpReceiveResult> ReceiveAsync()
{
var received = await _client.ReceiveAsync();
return(new Edison.Plugin.Common.Net.UdpReceiveResult(
received.Buffer,
new IPEndpoint(received.RemoteEndPoint.Address.ToString(), received.RemoteEndPoint.Port)));
}
public async Task <ReadDataResult> ReadDataAsync(int count, CancellationToken cancellationToken)
{
var result = await _client.ReceiveAsync();
return(new ReadDataResult
{
Data = result.Buffer,
Length = result.Buffer.Length
});
}
private async void InitListener()
{
while (true)
{
var result = await udpServer.ReceiveAsync();
var message = DateTime.Now.ToString("t") + ": " + Encoding.UTF8.GetString(result.Buffer);
lbMessages.Invoke(new Action(() => lbMessages.Items.Add(message)));
}
}
private void ReceiveData(IAsyncResult ar)
{
try
{
System.Net.Sockets.UdpClient listener = (System.Net.Sockets.UdpClient)ar.AsyncState;
byte[] data = listener.EndReceive(ar, ref endpoint);
#endif
if (data.Length < 16)
{
return;//bad request
}
UdpTrackerMessage request = UdpTrackerMessage.DecodeMessage(data, 0, data.Length, MessageType.Request);
switch (request.Action)
{
case 0:
ReceiveConnect((ConnectMessage)request);
break;
case 1:
ReceiveAnnounce((AnnounceMessage)request);
break;
case 2:
ReceiveScrape((ScrapeMessage)request);
break;
case 3:
ReceiveError((ErrorMessage)request);
break;
default:
throw new ProtocolException(string.Format("Invalid udp message received: {0}", request.Action));
}
}
catch (Exception e)
{
Logger.Log(null, e.ToString());
}
finally
{
if (Running)
{
#if NETSTANDARD1_5
result = await listener.ReceiveAsync();
ReceiveData(result, client);
#else
listener.BeginReceive(new AsyncCallback(ReceiveData), listener);
#endif
}
}
}
public void StartUdpServer (Form2 form2)
{
//myTimer.Interval = 50;
//myTimer.Tick += new EventHandler(myTimerTick);
publicForm2 = form2;
JsonHelper jsh = new JsonHelper();
Task.Run(async () =>
{
using (var udpClient = new UdpClient(9992))
{
StartConversation2(udpClient);
// SetTime(udpClient);
//string path = @"Jsons/" + jsh.deleteAllButNumbers(DateTime.Now.ToString()) + ".txt";
//File.Create(path);
string udpString = "";
while (true)
{
//IPEndPoint object will allow us to read datagrams sent from any source.
var receivedResults = await udpClient.ReceiveAsync();
udpString = Encoding.ASCII.GetString(receivedResults.Buffer);
//using (StreamWriter writetext = new StreamWriter(path, true))
//{
// writetext.WriteLine(udpString);
//}
// Blink(form2);
form2.Controls.Find("label3", true).FirstOrDefault().BackColor = Color.Green;
// TODO: timer, ktery za chvilku zmeni barvu zpet na cervenou
//myTimer.Start();
Monitor.Enter(lstBuffer);
lstBuffer.Add(udpString);
Monitor.Exit(lstBuffer);
// MessageBox.Show(loggingEvent);
}
}
});
}
public async Task<UdpReceiveResult> receiveBytesAsync(int port)
{
while (true)
{
try
{
UdpClient trasport = new UdpClient(port);
UdpReceiveResult result = await trasport.ReceiveAsync();
trasport.Close();
return result;
}
catch
{
Thread.Sleep(10);
}
}
}
public async Task SendTest()
{
// Arrange
var package = new ArtDmxPackage(new byte[] { 1, 2 });
var expected = package.GetBytes();
expected[12] = 2;
var receiver = new UdpClient(Sender.ArtNetDefaultPort);
var sender = new Sender("127.0.0.1");
// Act
var t = receiver.ReceiveAsync();
await sender.SendAsync(package);
var actual = (await t).Buffer;
// Assert
Assert.IsNotNull(actual);
CollectionAssert.AreEqual(expected, actual);
}
public async Task Start(string remoteServerIp, ushort remoteServerPort, ushort localPort, string localIp = null)
{
var clients = new ConcurrentDictionary <IPEndPoint, UdpClient>();
var server = new System.Net.Sockets.UdpClient(AddressFamily.InterNetworkV6);
server.Client.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false);
IPAddress localIpAddress = string.IsNullOrEmpty(localIp) ? IPAddress.IPv6Any : IPAddress.Parse(localIp);
server.Client.Bind(new IPEndPoint(localIpAddress, localPort));
Console.WriteLine($"UDP proxy started :{localIpAddress}|{localPort} -> {remoteServerIp}|{remoteServerPort}");
var _ = Task.Run(async() =>
{
while (true)
{
await Task.Delay(10000);
foreach (var client in clients.ToArray())
{
if (client.Value.lastActivity + TimeSpan.FromSeconds(60) < DateTime.UtcNow)
{
UdpClient c;
clients.TryRemove(client.Key, out c);
client.Value.Stop();
}
}
}
});
while (true)
{
try
{
var message = await server.ReceiveAsync();
var endpoint = message.RemoteEndPoint;
var client = clients.GetOrAdd(endpoint, ep => new UdpClient(server, endpoint, new IPEndPoint(IPAddress.Parse(remoteServerIp), remoteServerPort)));
await client.SendToServer(message.Buffer);
}
catch (Exception ex)
{
Console.WriteLine($"an exception occurred on recieving a client datagram: {ex}");
}
}
}
private static void Main()
{
using (var client = new UdpClient(Sender.ArtNetDefaultPort))
{
Console.WriteLine("Waiting for data.");
while (true)
{
var bytes = client.ReceiveAsync().Result.Buffer;
Console.WriteLine();
Console.WriteLine(BitConverter.ToString(bytes));
var pairs = ByteHelper.GetAddressesAndValuesFromMessage(bytes);
foreach (var pair in pairs)
{
Console.WriteLine("{0:000} = {1:000}", pair.Address, pair.Value);
}
}
}
}
public async Task ReceiveMessagesAsync() {
UdpClient objClient = null;
try {
while(true) {
objClient = new UdpClient(LocalEndPoint);
IPEndPoint objRemoteEndPoint;
UdpReceiveResult objResult = await objClient.ReceiveAsync();
objRemoteEndPoint = objResult.RemoteEndPoint;
string strText = Encoding.UTF8.GetString(objResult.Buffer);
await richTextBox1.Dispatcher.InvokeAsync(() => { richTextBox1.AppendText($"{objRemoteEndPoint.Address}:{objRemoteEndPoint.Port} {strText}\n"); });
objClient.Close();
}
}
catch(Exception ex) {
MessageBox.Show("ReceiveMessageAsync " + ex.Message);
}
}
public override void Start()
#endif
{
if (Running)
{
return;
}
//TODO test if it is better to use socket directly
//Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
listener = new System.Net.Sockets.UdpClient(endpoint.Port);
#if NETSTANDARD1_5
var receive = await listener.ReceiveAsync();
ReceiveData(receive, listener);
#else
listener.BeginReceive(new AsyncCallback(ReceiveData), listener);
#endif
}
public static IList<IPEndPoint> FindServers()
{
var rt = new List<IPEndPoint>();
foreach (var ip in GetLocalIPs())
{
UdpClient client = new UdpClient();
IPEndPoint sender = new IPEndPoint(IPAddress.Any, 8005);
client.Send(Encoding.UTF8.GetBytes(QUERY_MESSAGE), QUERY_MESSAGE.Length, new IPEndPoint(IPAddress.Broadcast, 8002));
var receiveTask = client.ReceiveAsync();
receiveTask.Wait(500);
if (!receiveTask.IsCompleted || Encoding.UTF8.GetString(receiveTask.Result.Buffer) != RESPONSE_MESSAGE)
continue;
rt.Add(receiveTask.Result.RemoteEndPoint);
}
return rt;
}
public static void WhenReceived(this UdpClient client, Action <UdpReceiveResult> action)
{
if (action == null)
{
throw new ArgumentNullException();
}
var key = client.GetHashCode();
if (udp_received_actions.ContainsKey(key))
{
var temp = Delegate.Combine(udp_received_actions[key], action);
udp_received_actions[key] = temp;
}
else
{
udp_received_actions[key] = action;
}
if (task_tokens.ContainsKey(key))
{
return;
}
var cts = new CancellationTokenSource();
var context = SynchronizationContext.Current;
Task.Run(async() =>
{
while (true)
{
try
{
if (cts.IsCancellationRequested)
{
break;
}
var r = await client.ReceiveAsync();
if (udp_received_actions.ContainsKey(key))
{
var a = udp_received_actions[key];
if (context == null)
{
a.DynamicInvoke(r);
}
else
{
context.Post(_ =>
{
a.DynamicInvoke(r);
}, null);
}
}
}
catch
{
if (task_tokens.TryRemove(key, out cts))
{
cts.Dispose();
}
break;
}
}
}, cts.Token).ConfigureAwait(false);
task_tokens[key] = cts;
}
//
// Summary:
// Receives a datagram from a remote host asynchronously.
//
// Parameters:
// requestCallback:
// An System.AsyncCallback delegate that references the method to invoke when the
// operation is complete.
//
// state:
// A user-defined object that contains information about the receive operation.
// This object is passed to the requestCallback delegate when the operation is complete.
//
// Returns:
// An System.IAsyncResult object that references the asynchronous receive.
public static IAsyncResult BeginReceive(this UdpClient client, AsyncCallback requestCallback, object state)
{
return(TaskToApm.Begin(client.ReceiveAsync(), requestCallback, state));
}
public Task <UdpReceiveResult> ReceiveAsync()
{
return(_udpClient.ReceiveAsync());
}
public static async Task Start()
{
var client = new UdpClient(1812);
var serializer = new RadiusPacketSerializer();
while (true)
{
try
{
var result = await client.ReceiveAsync();
var request = serializer.Read(result.Buffer);
Console.WriteLine(request.Dump());
if (request.Code == RadiusPacketCode.AccessRequest)
{
var password = (RadiusBinaryAttribute)request.Attributes.FirstOrDefault(a => a.Type == RadiusAttributeType.UserPassword);
var code = ((password == null) || (string.Compare(RadiusPacketSerializer.DecodePassword(Secret, request.Authenticator, password.Value), Password, StringComparison.InvariantCulture) != 0))
? RadiusPacketCode.AccessReject
: RadiusPacketCode.AccessAccept;
var response = new RadiusPacket
{
Code = code,
Identifier = request.Identifier,
Authenticator = request.Authenticator
};
var buffer = serializer.Write(response);
await client.SendAsync(buffer, buffer.Length, result.RemoteEndPoint);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
public async Task<IEnumerable<Server>> GetServers(
MasterServerRegion region = MasterServerRegion.All,
params MasterServerFilter[] masterServerFilters)
{
var servers = new List<Server>();
using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
{
client.Connect(_steamSteamIpAddress, _steamSteamPort);
string thisServer = null;
while (thisServer != FIRST_AND_LAST_SERVER)
{
var requestPacket = CreateRequestPacket(thisServer ?? FIRST_AND_LAST_SERVER, region, masterServerFilters);
await client.SendAsync(requestPacket, requestPacket.Length);
var response = await client.ReceiveAsync();
var responseData = response.Buffer.ToList();
for (int i = HEADER_BYTES_LENGTH; i < responseData.Count; i++)
{
var ip = string.Join(".", responseData.GetRange(i, 4).ToArray());
int port = responseData[i + 4] << 8 | responseData[i + 5];
thisServer = string.Format("{0}:{1}", ip, port);
if (thisServer != FIRST_AND_LAST_SERVER)
{
servers.Add(new Server(new IPEndPoint(IPAddress.Parse(ip), port)));
}
i += 5;
}
}
}
return servers;
}
private async void StartUdpServer()
{
var endPoint = new IPEndPoint(IPAddress.Any, 0);
var udp = new UdpClient(8080);
IHubContext context = GlobalHost.ConnectionManager.GetHubContext<LogMessageHub>();
while (true)
{
UdpReceiveResult received = await udp.ReceiveAsync();
//TODO: Are we still listening for UDP messages at this point?
var buffer = received.Buffer;
var xmlText = Encoding.UTF8.GetString(buffer);
var logEvent = new LogEvent();
logEvent.PopulateFromLog4JXml(xmlText);
var json = logEvent.ToJson();
//This should be in the hub wrapper
var applicationId = logEvent.ApplicationId;
if (applicationId != null)
context.Clients.Group(applicationId).newLogMessage(json);
}
}
private static async Task ReceiveAndCheckAsync(UdpClient client, string expectedMessage)
{
var incomingBytes = new List<byte>();
var connectionReset=false;
try
{
do
{
var udpReceiveResult = await client.ReceiveAsync();
incomingBytes.AddRange(udpReceiveResult.Buffer);
} while (TcpMessenger.IsReadingShouldContinue(incomingBytes));
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.ConnectionReset)
{
connectionReset = true;
}
}
var actual = Encoding.UTF8.GetString(incomingBytes.ToArray());
if (connectionReset)
{
TcpMessenger.ErrorConnectionReset(actual);
}
else if (actual != expectedMessage)
{
TcpMessenger.ErrorWrongMessage(actual);
}
}
public async Task BeginListeningAsync (CancellationToken token)
{
var client = new UdpClient (BroadcastEndpoint);
client.JoinMulticastGroup (BroadcastEndpoint.Address);
token.Register (() => client.Close ());
while (true) {
token.ThrowIfCancellationRequested ();
try {
var result = await client.ReceiveAsync ();
var data = Encoding.UTF8.GetString (result.Buffer);
if (data.StartsWith (Header, StringComparison.Ordinal)) {
if (ServerFound != null) {
var details = new ServerDetails {
Hostname = result.RemoteEndPoint.Address.ToString (),
Port = int.Parse (data.Substring (Header.Length))
};
LoggingService.LogInfo ("Found TunezServer at {0}", details.FullAddress);
ServerFound (this, details);
}
}
} catch (ObjectDisposedException) {
token.ThrowIfCancellationRequested ();
throw;
} catch (SocketException) {
token.ThrowIfCancellationRequested ();
// Ignore this
} catch (Exception ex) {
token.ThrowIfCancellationRequested ();
LoggingService.LogInfo ("Ignoring bad UDP {0}", ex);
}
}
}
public static async Task<BufferReader> ReceiveBufferReaderAsync(UdpClient client, int headerSize)
{
var response = await client.ReceiveAsync();
var reader = new BufferReader(response.Buffer);
reader.Skip(headerSize);
return reader;
}
public async Task<byte[]> receiveBytesAsync(int port)
{
UdpClient trasport = new UdpClient(port);
// IPEndPoint ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
UdpReceiveResult result = await trasport.ReceiveAsync();
byte[] bytes = result.Buffer;
trasport.Close();
return bytes;
}
private void Receive(UdpClient udpClient)
{
udpClient.ReceiveAsync().ContinueWith(res =>
{
if (DataReceived != null)
DataReceived(res.Result.RemoteEndPoint, CommandBase.Parse(res.Result.Buffer));
Receive(udpClient);
});
}
public async Task<ServerRulesResult> GetServerRules()
{
using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
{
client.Connect(EndPoint);
var requestPacket = new List<byte>();
requestPacket.AddRange(new Byte[] {0xFF, 0xFF, 0xFF, 0xFF, 0x56});
requestPacket.AddRange(BitConverter.GetBytes(-1));
await client.SendAsync(requestPacket.ToArray(), requestPacket.ToArray().Length);
UdpReceiveResult response = await client.ReceiveAsync();
List<byte> responseData = response.Buffer.ToList();
requestPacket.Clear();
requestPacket.AddRange(new Byte[] {0xFF, 0xFF, 0xFF, 0xFF, 0x56});
requestPacket.AddRange(responseData.GetRange(5, 4));
await client.SendAsync(requestPacket.ToArray(), requestPacket.ToArray().Length);
response = await client.ReceiveAsync();
return ServerRulesResult.Parse(response.Buffer);
}
}
private async Task<ReceiveDataInfo> ReceiveDataAsync(ServerAddress address, byte[] data, CancellationToken ct, params char[] header)
{
var udpClient = new UdpClient();
var ipAddr = IPAddress.Parse(address.Ip);
try
{
udpClient.Connect(ipAddr, address.Port);
var sendTime = DateTime.Now;
await udpClient.SendAsync(data, data.Length);
Packet packet = null;
return await Task.Run(async () =>
{
while (true)
{
var clientResult = await udpClient.ReceiveAsync().WithCancellation(ct);
var remoteIp = clientResult.RemoteEndPoint.Address.ToString();
var remotePort = clientResult.RemoteEndPoint.Port;
var receiveDate = DateTime.Now;
var packetReader = new PacketReader(clientResult.Buffer);
var packetheader = packetReader.ReadLong();
if (packet == null)
{
packet = engineFactory.CreatePacket(packetheader);
}
packet.AddData(clientResult.Buffer);
if (packet.IsCompleted)
{
var messageReader = new PacketReader(packet.Payload);
var messageheader = messageReader.ReadByte();
var messageHeaderChar = Convert.ToChar(messageheader);
if (header.Contains(messageHeaderChar))
{
var result = new ReceiveDataInfo
{
Ping = (int)(DateTime.Now - sendTime).TotalMilliseconds,
Data = packet.Payload,
MessageHeaderChar = messageHeaderChar,
};
return result;
}
}
}
});
}
catch
{
throw new OperationCanceledException();
}
finally
{
udpClient.Close();
}
}
protected async void udpReceiveAsync(int port, HandleMessage handleMessage)
{
IPEndPoint remoteIP = new IPEndPoint(IPAddress.Any, port);
UdpClient udpClient = new UdpClient(remoteIP);
while (true)
{
UdpReceiveResult rst = await udpClient.ReceiveAsync();
handleMessage(Encoding.ASCII.GetString(rst.Buffer), rst.RemoteEndPoint.Address);
}
}
public static async Task ServeAsync(UdpClient server)
{
IDictionary<IPEndPoint, List<byte>> received=new Dictionary<IPEndPoint, List<byte>>();
var sendTasks = new List<Task>();
while (_sent < Constants.ClientCount)
{
await server.ReceiveAsync()
.ContinueWith(udpReceivedResult => sendTasks.Add(AddReceivedToDicAndSendIfShouldAsync(server, udpReceivedResult.Result, received)));
}
await Task.WhenAll(sendTasks);
}
/// <summary>
/// Scans the network for game instances sending a broadcast.
/// </summary>
/// <returns>The game instances.</returns>
public async Task<NetworkGameInstance> DiscoverGameInstanceAsync (CancellationToken ct = default(CancellationToken))
{
NetworkGameInstance instance = null;
using(var client = new UdpClient (this.Port))
{
UdpReceiveResult receiveResult = await client.ReceiveAsync ();
string json = Encoding.UTF8.GetString (receiveResult.Buffer);
instance = json.FromJsonString <NetworkGameInstance>();
// With UDP, the sender IP can be obtained upon reception of the message.
instance.SenderAddress = receiveResult.RemoteEndPoint.Address.ToString ();
}
return instance;
}
static async Task ServerAsync(CancellationToken ct)
{
throw new ApplicationException("died");
var client = new UdpClient(5555);
var request = new byte[0];
while (!ct.IsCancellationRequested)
{
await client.SendAsync(request, request.Length);
var response = await client.ReceiveAsync();
}
}
public async Task TestUdpTraceListener()
{
int port = 11000;
var udpclient = new UdpClient(port);
var traceSource = new TraceSource("UnitTestLogger");
traceSource.Listeners.Remove("Default");
traceSource.Switch.Level = SourceLevels.All;
traceSource.Listeners.Add(new UdpTraceListener(IPAddress.Loopback, port));
traceSource.TraceEvent(TraceEventType.Information, 100, "Boris");
var dgram = await udpclient.ReceiveAsync();
var receivedText = Encoding.UTF8.GetString(dgram.Buffer);
Assert.Equal("UnitTestLogger Information: 100 : ", receivedText);
dgram = await udpclient.ReceiveAsync();
receivedText = Encoding.UTF8.GetString(dgram.Buffer);
Assert.Equal("Boris\r\n", receivedText);
udpclient.Close();
traceSource.Close();
}
public UdpCanPort(IPEndPoint LocalEnpPoint, IPEndPoint RemoteEndPoint)
{
_client = new UdpClient(LocalEnpPoint);
_client.Connect(RemoteEndPoint);
IConnectableObservable<ITransaction<CanFrame>> rx =
Observable.Defer(() => _client.ReceiveAsync().ToObservable())
.Repeat()
.Select(CreateCanTransaction)
.Publish();
Rx = rx;
_rxConnection = rx.Connect();
Options = new UdpCanPortOptions();
}
public async Task<ServerInfoResult> GetServerInfo()
{
using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
{
client.Connect(EndPoint);
var requestPacket = new List<byte>();
requestPacket.AddRange(new Byte[] { 0xFF, 0xFF, 0xFF, 0xFF});
requestPacket.Add(0x54);
requestPacket.AddRange(Encoding.ASCII.GetBytes("Source Engine Query"));
requestPacket.Add(0x00);
await client.SendAsync(requestPacket.ToArray(), requestPacket.ToArray().Length);
UdpReceiveResult response = await client.ReceiveAsync();
return ServerInfoResult.Parse(response.Buffer);
}
}
private async void FindServer(TaskCompletionSource<IPEndPoint> taskCompletionSource, int timeout)
{
// Create a udp client
var client = new UdpClient(new IPEndPoint(IPAddress.Any, GetRandomUnusedPort()));
client.Client.ReceiveTimeout = timeout;
// Construct the message the server is expecting
var bytes = Encoding.UTF8.GetBytes("who is MediaBrowserServer?");
// Send it - must be IPAddress.Broadcast, 7359
var targetEndPoint = new IPEndPoint(IPAddress.Broadcast, 7359);
// Send the broadcast
await client.SendAsync(bytes, bytes.Length, targetEndPoint).ConfigureAwait(false);
try
{
// Get a result back
var result = await client.ReceiveAsync().ConfigureAwait(false);
if (result.RemoteEndPoint.Port == targetEndPoint.Port)
{
// Convert bytes to text
var text = Encoding.UTF8.GetString(result.Buffer);
// Expected response : MediaBrowserServer|192.168.1.1:1234
// If the response is what we're expecting, proceed
if (text.StartsWith("mediabrowserserver", StringComparison.OrdinalIgnoreCase))
{
text = text.Split('|')[1];
var vals = text.Split(':');
var endpoint = new IPEndPoint(IPAddress.Parse(vals[0]), int.Parse(vals[1]));
taskCompletionSource.SetResult(endpoint);
return;
}
}
taskCompletionSource.SetException(new ArgumentException("Unexpected response"));
}
catch (SocketException ex)
{
taskCompletionSource.SetException(ex);
}
}
public async Task<MonoServerInformation> SearchServer(CancellationToken token)
{
using (var udp = new UdpClient(new IPEndPoint(IPAddress.Any, 15000)))
{
Task result = await Task.WhenAny(udp.ReceiveAsync(), Task.Delay(500, token));
var task = result as Task<UdpReceiveResult>;
if (task != null)
{
UdpReceiveResult udpResult = task.Result;
string msg = Encoding.Default.GetString(udpResult.Buffer);
return new MonoServerInformation { Message = msg, IpAddress = udpResult.RemoteEndPoint.Address };
}
}
return null;
}
public Instance(IParser packetParser, IPEndPoint localPacketEndpoint)
{
_packetParser = packetParser;
_localPacketEndpoint = localPacketEndpoint;
_udpClient = new UdpClient();
_udpClient.Client.Bind(_localPacketEndpoint);
_readings = Observable.FromAsync(() => _udpClient.ReceiveAsync()).Repeat()
.Select(result => result.Buffer)
.Select(Encoding.ASCII.GetString)
.Do(Instrumentation.Packet.Endpoint.Receive)
.SelectMany(_packetParser.GetReadings)
.Do(Instrumentation.Packet.Endpoint.Reading)
.Publish();
}
public void CanLoadThousandBots()
{
UdpClient udpServer = new UdpClient(44453);
IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 44453);
Core c = new Core();
for (int i = 0; i < 1000; i++)
{
Task<UdpReceiveResult> result = udpServer.ReceiveAsync();
BotClient client = c.AddBot();
client.Session.Connect(endpoint);
client.Session.SendAsync(Encoding.ASCII.GetBytes("Testing: " + i));
Assert.AreEqual<string>("Testing: " + i, Encoding.ASCII.GetString(result.Result.Buffer));
}
Assert.AreEqual<int>(1000, c.BotClients.Count);
}
public static async Task Test()
{
using (var udp = new UdpClient())
{
var listenEndpoint = new IPEndPoint(IPAddress.Any, 5321);
udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udp.ExclusiveAddressUse = false;
udp.Client.Bind(listenEndpoint);
while (true)
{
var response = await udp.ReceiveAsync();
Console.WriteLine(response.RemoteEndPoint.Address.ToString());
}
}
}