private void AutoDetectServers()
{
// 33848
try
{
UdpClient client = new UdpClient(555);
client.AllowNatTraversal(true);
client.EnableBroadcast = true;
client.Connect(IPAddress.Parse("255.255.255.255"), 33848);
byte[] message = Encoding.ASCII.GetBytes("Hello");
client.Send(message, message.Length);
var response = client.ReceiveAsync();
response.ContinueWith(x =>
{
if (!x.IsFaulted)
{
var temp = x.Result;
string data = Encoding.UTF8.GetString(temp.Buffer);
var xml = XElement.Parse(data);
var urlElement = xml.Elements("url").FirstOrDefault();
AddServers(new[] { (string)urlElement });
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
catch (Exception e)
{
s_logger.Error(e.Message, e);
}
}
public static async Task <Response> Query(Request request, IEnumerable <IPAddress> servers)
{
var requestByte = Writer.Serialize(request);
var buffer = new byte[32 * 1024];
var client = new UdpClient();
client.AllowNatTraversal(true);
client.DontFragment = true;
client.Client.ReceiveTimeout = 2000;
client.Client.SendTimeout = 2000;
for (int intAttempts = 0; intAttempts < 3; intAttempts++)
{
foreach (var server in servers)
{
try
{
await client.SendAsync(requestByte, requestByte.Length, new IPEndPoint(server, 53));
var response = await client.ReceiveAsync();
return(Reader.ReadResponse(response.Buffer));
}
catch (SocketException)
{
continue; // next try
}
catch (Exception ex)
{
}
}
}
return(new Response());
}
/// <summary>
/// 监听某个端口进行消息收取
/// </summary>
public bool Listen()
{
try
{
LoggerFactory.Debug("listen prepare");
IPEndPoint localIpEp = new IPEndPoint(IP, Port);
_client = new UdpClient(localIpEp)
{
EnableBroadcast = true
};
_client.AllowNatTraversal(true);
_client.Client.ReceiveBufferSize = this.ReceiveBufferSize;
//开始接受消息
_client.BeginReceive(AsyncReceiveHandler, null);
this._state = ClientState.Working;
LoggerFactory.Debug("begin receive");
//由于UI处理时间比较长，开启收包处理任务
StartReceiveTask();
LoggerFactory.Debug("receive task started");
return(true);
}
catch (Exception e)
{
OnError(Errors.OutofSizePacket, "监听错误。可能端口已经被其他程序占用。查看端口占用进程请执行：netstat -ano | findstr " + this.Port, e);
}
return(false);
}
public UdpClient StartIfNot()
{
if (_udpClient == null)
{
_stop = false;
_udpClient = new UdpClient();
_udpClient.ExclusiveAddressUse = false;
IPEndPoint localEp = new IPEndPoint(IPAddress.Any, _port);
_udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_udpClient.ExclusiveAddressUse = false;
_udpClient.JoinMulticastGroup(IPAddress.Parse(_ip), 64);
_udpClient.AllowNatTraversal(true);
_udpClient.Client.Bind(localEp);
_udpClient.MulticastLoopback = true;
_receiveThread = new Thread(Receive);
#if !DEBUG
_receiveThread.IsBackground = true;
#endif
_receiveThread.Start();
}
return(_udpClient);
}
/// <summary>
/// UDP接收器
/// </summary>
/// <param name="listenPort">监听的端口</param>
public UdpReceiver(int listenPort)
{
this.Encoding = Encoding.Default;
this.ListenPort = listenPort;
udpClient = new UdpClient(listenPort);
udpClient.AllowNatTraversal(true);
}
/////////////////////////////////////////////////////////////////////
// CONSTRUCTOR
/////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates an OTEX server listener.
/// </summary>
/// <exception cref="Exception" />
public ServerListener()
{
//create udp client
UdpClient udpClient = null;
for (int i = Server.AnnouncePorts.First; i <= Server.AnnouncePorts.Last && udpClient == null; ++i)
{
try
{
udpClient = new UdpClient(i);
}
catch (Exception) { };
}
if (udpClient == null)
{
throw new Exception(string.Format("Could not acquire a socket on any port in the range {0}."
+ " (Are there many instances of ServerListener running?)", Server.AnnouncePorts));
}
//configure client
udpClient.EnableBroadcast = true;
udpClient.AllowNatTraversal(true);
//create thread
thread = new Thread(ControlThread);
thread.Name = "OTEX ServerListener ControlThread";
thread.IsBackground = false;
thread.Start(udpClient);
}
public void StartListener()
{
bool done = false;
UdpClient listener = new UdpClient(receptionPort + 1000 + arena.Me.id);
IPEndPoint RemoteEndPoint = new IPEndPoint(remoteAddress, receptionPort - 1);
listener.AllowNatTraversal(true);
//UDP hole punch
listener.Send(new byte[10], 10, RemoteEndPoint);
//start listening
try
{
while (!done)
{
Thread.Sleep(15);
this.receive_buffer = listener.Receive(ref RemoteEndPoint);
//System.Console.WriteLine("Received packet");
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{
listener.Close();
}
}
private static STUN_Result StunUDP(UdpClient socket)
{
socket.AllowNatTraversal(true);
var servers = new[] { "stun.l.google.com:19302", "stun.services.mozilla.com", "stunserver.org" };
foreach (var server in servers)
{
var host = server.Split(':').FirstOrDefault();
try
{
int port;
if (!int.TryParse(server.Split(':').LastOrDefault(), out port) || (port == 0))
{
port = 3478;
}
return(STUN_Client.Query(host, port, socket.Client));
}
catch (Exception ex)
{
Trace.TraceWarning("STUN request to {0} failed : {1}", host, ex);
}
}
return(null);
}
private void Broadcast()
{
UdpClient client = new UdpClient();
client.AllowNatTraversal(true);
client.EnableBroadcast = true;
while (!tokenSource.IsCancellationRequested)
{
CancellationTokenSource internalSource = new CancellationTokenSource();
IPEndPoint serverEndpoint = new IPEndPoint(IPAddress.Any, Port);
byte[] data = new byte[] { 0x00 };
client.Send(data, data.Length, new IPEndPoint(IPAddress.Broadcast, Port));
Task.Factory.StartNew(() =>
{
client.Receive(ref serverEndpoint);
messageReceived.Set();
}
, internalSource.Token);
if (messageReceived.WaitOne(PollingTime))
{
ServerDiscoveredEventArgs args = new ServerDiscoveredEventArgs(serverEndpoint.Address.ToString(), new byte[] { 0x00 });
ServerDiscovered?.Invoke(this, args);
}
internalSource.Cancel();
}
}
internal SSDPWorker(SSDPProperties theProperties)
{
m_Properties = theProperties;
var host = Dns.GetHostEntry(Dns.GetHostName());
foreach (var ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
var UdpClient = new UdpClient();
UdpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
UdpClient.Client.Bind(new IPEndPoint(ip, 0));
var ReceiveHandler = new SSDPReceive(UdpClient, ip);
ReceiveHandler.DeviceDiscovered += OnDeviceDiscovered;
try
{
UdpClient.AllowNatTraversal(true);
}
catch (SocketException)
{
}
m_UdpClients.Add(UdpClient);
ReceiveHandler.BeginReceive();
}
}
}
protected override void OnConnect()
{
_udp = new UdpClient(new IPEndPoint(IPAddress.Any, 0));
_udp.AllowNatTraversal(true);
_isReady = false;
_isClearing = false;
}
private void floodUdp() // all the upcoming code happens every second or so
{
string ipaddr = IPText.Text;
var checkedudp = CheckIP(ipaddr);
int por = Int32.Parse(portText.Text);
UdpClient client = new UdpClient(); // this is just the udp client, nothing interesting
if (checkedudp)
{
try
{
client.Connect(ipaddr, por); // this is where the fun starts
byte[] sendBytes = Encoding.ASCII.GetBytes(DataText.Text);
client.Send(sendBytes, sendBytes.Length); // this actually sends the packet
client.AllowNatTraversal(true);
client.DontFragment = true;
}
catch
{
MessageBox.Show("There was an error with npf. Ensure that you have an internet connection and that all the data is entered correctly.");
floodTimer.Stop();
}
}
else
{
MessageBox.Show("The IP address is invalid or cannot be pinged at this time. Please enter a valid IP address");
floodTimer.Stop();
}
}
public void AllowNatTraversal_AnyUnix(bool allow)
{
using (var c = new UdpClient())
{
Assert.Throws <PlatformNotSupportedException>(() => c.AllowNatTraversal(allow));
}
}
public StepperController(string ipAddress)
{
IpAddress = ipAddress;
_udpClient = new UdpClient(7777);
_udpClient.AllowNatTraversal(true);
//_udpClient.ExclusiveAddressUse = false;
_udpClient.Connect(IpAddress, 7775);
}
public void AllowNatTraversal_Windows(bool allow, IPProtectionLevel resultLevel)
{
using (var c = new UdpClient())
{
c.AllowNatTraversal(allow);
Assert.Equal((int)resultLevel, (int)c.Client.GetSocketOption(SocketOptionLevel.IP, SocketOptionName.IPProtectionLevel));
}
}
public void Listen()
{
//start threads
//packets that need processing
new Thread(ProcessPackets).Start();
//outgoing packets
new Thread(SendPendingPackets).Start();
var port = _serverSettings.ServerListeningPort();
_listener = new UdpClient();
_listener.AllowNatTraversal(true);
_listener.ExclusiveAddressUse = true;
_listener.DontFragment = true;
_listener.Client.DontFragment = true;
_listener.Client.Bind(new IPEndPoint(IPAddress.Any, _serverSettings.ServerListeningPort()));
while (!_stop)
{
try
{
var groupEP = new IPEndPoint(IPAddress.Any, port);
var rawBytes = _listener.Receive(ref groupEP);
if ((rawBytes != null) && (rawBytes.Length >= 22))
{
_pendingProcessingPackets.Add(new PendingPacket
{
RawBytes = rawBytes,
ReceivedFrom = groupEP
});
}
else if ((rawBytes != null) && (rawBytes.Length == 15) && (rawBytes[0] == 1) && (rawBytes[14] == 15))
{
try
{
//send back ping UDP
_listener.Send(rawBytes, rawBytes.Length, groupEP);
}
catch (Exception ex)
{
//dont log because it slows down thread too much...
}
}
}
catch (Exception e)
{
// logger.Error(e,"Error receving audio UDP for client " + e.Message);
}
}
try
{
_listener.Close();
}
catch (Exception e)
{
}
}
public static async Task <int> SendAsync(int port, byte[] bytes)
{
using (var udpClient = new UdpClient(AddressFamily.InterNetwork))
{
udpClient.ExclusiveAddressUse = false;
udpClient.AllowNatTraversal(true);
return(await udpClient.SendAsync(bytes, bytes.Length, new IPEndPoint(IPAddress.Broadcast, port)));
}
}
/// <summary>
/// Configures the UDP client.
/// </summary>
/// <param name="endpoint">Endpoint that the client will be communicating with.</param>
public override void Setup(ConnectionEndpoint endpoint)
{
EndPoint = endpoint;
Client = new UdpClient();
// TODO: Solve for .NET Standard, this is possibly default behaviour (???)
#if !WINDOWS_UWP
Client.AllowNatTraversal(true);
#endif
}
/// <summary>
/// Closes, resets and restarts the UDP server.
/// </summary>
public void Restart()
{
Close();
Listener = new UdpClient(Port);
Listener.EnableBroadcast = true;
Listener.AllowNatTraversal(true);
Status = false;
running = false;
Start();
}
public UdpStreamSender()
{
_queue = new ConcurrentQueue <StreamPacket>();
_waiter = new ManualResetEvent(false);
_udpClient = new UdpClient();
_udpClient.AllowNatTraversal(true);
_senderThread = new Thread(new ThreadStart(WorkThread));
}
public Beacon(IPAddress localIp, string serviceId, ushort port, string serviceName)
{
Message = new BeaconMessage(serviceId, port, serviceName);
_udp = new UdpClient(new IPEndPoint(localIp, Protocol.DiscoveryPort));
_udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_udp.AllowNatTraversal(true);
_udp.BeginReceive(Receive, null);
}
public UdpService(IPAddress iPAddress, int port)
{
_serverIp = iPAddress;
_port = port;
_serverIPEndpoint = new IPEndPoint(_serverIp, _port);
_client = new UdpClient();
_client.Client.SetIPProtectionLevel(IPProtectionLevel.Unrestricted);
_client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_client.AllowNatTraversal(true);
}
/// <summary>
/// Instantiates an instances of the UdpServerHandler class using the specified SocketBinder and parameters.
/// </summary>
/// <param name="binder">SocketBinder to bind a new socket too.</param>
/// <param name="port">Port used for receiving.</param>
/// <param name="alignment">Default alignment in bytes for buffers.</param>
/// <param name="packetHeader">Collection of bytes used for packet verification.</param>
public UdpServerHandler(SocketBinder binder, int port, int alignment) : base(binder)
{
Port = port;
Alignment = (alignment > 0) ? alignment : 1;
running = false;
Listener = new UdpClient(port);
Listener.EnableBroadcast = true;
Listener.AllowNatTraversal(true);
}
public NativeUdpClient(AudioSender audioSender)
{
_audioSender = audioSender;
_key = _audioSender.GetUniqueIdentifier();
_client = new UdpClient();
// TODO: Solve for .NET Standard, this is possibly default behaviour (???)
#if HAS_NAT_TRAVERSAL
_client.AllowNatTraversal(true);
#endif
}
private void Init()
{
_resendThread = new Thread(Resend);
_resendThread.Start();
_heartbeatThread = new Thread(Beat);
_heartbeatThread.Start();
_client.AllowNatTraversal(true);
_client.DontFragment = true;
_client.BeginReceive(OnReceiveDatagram, null);
}
public void Listen()
{
_udpLastReceived = 0;
_listener = new UdpClient();
try
{
_listener.AllowNatTraversal(true);
}
catch { }
var decoderThread = new Thread(UdpAudioDecode)
{
Name = $"{_mainClient.LogClientId}| Audio Decoder"
};
decoderThread.Start();
StartTransmissionEndCheckTimer();
StartPing();
_packetNumber = 1; //reset packet number
var localListenEndpoint = new IPEndPoint(IPAddress.Any, 0); // 0 means random unused port
while (!_stop)
{
try
{
var bytes = _listener.Receive(ref localListenEndpoint);
if (bytes.Length == 22)
{
_udpLastReceived = DateTime.Now.Ticks;
Logger.Trace($"{_mainClient.LogClientId}| Received UDP Ping Back from Server");
}
else if (bytes.Length > 22)
{
_udpLastReceived = DateTime.Now.Ticks;
_encodedAudio.Add(bytes);
}
}
catch (Exception e)
{
Logger.Error(e, $"{_mainClient.LogClientId}| Error Receiving UDP data from Server");
}
}
//stop UI Refreshing
_updateTimer.Stop();
_mainClient.Disconnect();
}
public StepperController(string ipAddress)
{
_source = new CancellationTokenSource();
_cancellationToken = _source.Token;
IPAddress.TryParse(ipAddress, out IPAddress ip);
Sm.Ip = ip;
_udpClient = new UdpClient(SendPort);
_udpClient.AllowNatTraversal(true);
//_udpClient.ExclusiveAddressUse = false;
_udpClient.Connect(Sm.Ip, ListenPort);
}
public void retrieveHostEntries()
{
string hostName = Dns.GetHostName();
foreach (IPAddress interfaceIP in (from ip in Dns.GetHostEntry(hostName).AddressList where ip.AddressFamily == AddressFamily.InterNetwork select ip))
{
UdpClient client = new UdpClient();
client.AllowNatTraversal(true);
client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
client.Client.Bind(new IPEndPoint(interfaceIP, multicastGroup.Port));
client.JoinMulticastGroup(this.multicastGroup.Address);
this.hostEntries.Add(client);
}
}
private async void SendUDPMessage()
{
byte[] message = Encoding.ASCII.GetBytes("Hello");
var address = IPAddress.Parse("239.77.124.213");
using (UdpClient client = new UdpClient())
{
client.AllowNatTraversal(true);
client.JoinMulticastGroup(address);
await client.SendAsync(message, message.Length, new IPEndPoint(address, 33848)).ConfigureAwait(false);
client.Close();
}
}
private void Form1_Load(object sender, EventArgs e)
{
butIML.ImageSize = new Size(playpauseBUT.Size.Width - 1, playpauseBUT.Size.Height - 1); // This ensures the play and pause buttons are always the same size as the button they are encased in
stopBUT.Size = playpauseBUT.Size; // Ensures the stop button is the same size as the play/pause button.
stopBUT.Location = new Point(stopBUT.Location.X, playpauseBUT.Location.Y);
pub.AllowNatTraversal(false); // Disables the ability for the program to communicate with the outside world, for security purposes
try { pub.BeginReceive(new AsyncCallback(RecvPub), null); }
catch (Exception err) { MessageBox.Show("An error occurred!\n" + err.ToString()); Application.Exit(); }
tlisten.AllowNatTraversal(false);
BeginListening(); // Begins listening for attempts to connect to the client via TCP
Announce_Client_Connect(); // Announce to the local network that we are running
}
public void AllowNatTraversal_Windows(bool allow, IPProtectionLevel resultLevel)
{
using (var c = new UdpClient())
{
c.AllowNatTraversal(allow);
Assert.Equal((int)resultLevel, (int)c.Client.GetSocketOption(SocketOptionLevel.IP, SocketOptionName.IPProtectionLevel));
}
}
public void AllowNatTraversal_AnyUnix(bool allow)
{
using (var c = new UdpClient())
{
Assert.Throws<PlatformNotSupportedException>(() => c.AllowNatTraversal(allow));
}
}
