| public JoinMulticastGroup ( IPAddress multicastAddr ) : void | ||
| multicastAddr | IPAddress | |
| return | void | |
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));
}
}
}
public ServerContext(int port, int maxclients, ref List<string> TextStack, string OwnIP)
{
BeginSendUdpServerCallback = new AsyncCallback(OnBeginSendUdpServerCallbackFinished);
ServerMessage = System.Text.Encoding.ASCII.GetBytes("OK:" + OwnIP);
UdpServer = new UdpClient(new IPEndPoint(IPAddress.Any, 8011)); //da bei xp fehler
UdpServer.JoinMulticastGroup(BroadcastServer.Address);
UdpServer.BeginSend(ServerMessage, ServerMessage.Length, BroadcastServer, BeginSendUdpServerCallback, null);
MaxClients = maxclients;
Ip = IPAddress.Any;
this.Port = port;
listener = new TcpListener(Ip, Port);
Clients = new List<ClientContext>(MaxClients);
listener.Start();
BeginAcceptSocketCallback = new AsyncCallback(OnClientConnected);
this.TextStack = TextStack;
}
/// <summary>
/// Start the connection
/// </summary>
public override void Connect()
{
try
{
IEnumerable<IPAddress> ipv4Addresses =
Dns
.GetHostAddresses(Dns.GetHostName())
.Where(i => i.AddressFamily == AddressFamily.InterNetwork);
foreach (IPAddress localIp in ipv4Addresses)
{
var client = new UdpClient(new IPEndPoint(localIp, _localEndpoint.Port));
_udpClients.Add(client);
client.JoinMulticastGroup(ConnectionConfiguration.IpAddress, localIp);
}
}
catch (SocketException ex)
{
throw new ConnectionErrorException(ConnectionConfiguration, ex);
}
// TODO: Maybe if we have a base Connect helper which takes in a KnxReceiver and KnxSender,
// we can make the property setters more restricted
KnxReceiver = new KnxReceiverRouting(this, _udpClients);
KnxReceiver.Start();
KnxSender = new KnxSenderRouting(this, _udpClients, RemoteEndpoint);
Connected();
}
public void Initialize()
{
tcpServer = new TcpListener(IPAddress.Any, 1901);
tcpServer.BeginAcceptTcpClient()
sender = new UdpClient();
sender.DontFragment = true;
sender.JoinMulticastGroup(remoteEndPoint.Address);
listener = new UdpClient();
listener.ExclusiveAddressUse = false;
listener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
listener.ExclusiveAddressUse = false;
listener.Client.Bind(anyEndPoint);
listener.DontFragment = true;
listener.JoinMulticastGroup(remoteEndPoint.Address);
listener.BeginReceive(ReceiveCallback, null);
}
private void HandleBroadcasts()
{
var localIP = new IPEndPoint(IPAddress.Any, 50001);
var udpClient = new UdpClient();
udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udpClient.ExclusiveAddressUse = false;
udpClient.Client.Bind(localIP);
var multicastingIP = IPAddress.Parse("228.5.6.7");
udpClient.JoinMulticastGroup(multicastingIP);
running = true;
while (running)
{
var bytes = udpClient.Receive(ref localIP);
var message = Encoding.UTF8.GetString(bytes);
Dispatcher.Invoke(() =>
{
lblResponse.Content = message;
});
}
udpClient.DropMulticastGroup(multicastingIP);
udpClient.Close();
}
public SearchSniffer()
{
IPAddress[] LocalAddresses = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
ArrayList temp = new ArrayList();
foreach (IPAddress i in LocalAddresses) temp.Add(i);
temp.Add(IPAddress.Loopback);
LocalAddresses = (IPAddress[])temp.ToArray(typeof(IPAddress));
for (int id = 0; id < LocalAddresses.Length; ++id)
{
try
{
var localEndPoint = new IPEndPoint(LocalAddresses[id], 1900);
UdpClient ssdpSession = new UdpClient(localEndPoint);
ssdpSession.MulticastLoopback = false;
ssdpSession.EnableBroadcast = true;
if (localEndPoint.AddressFamily == AddressFamily.InterNetwork)
{
ssdpSession.JoinMulticastGroup(UpnpMulticastV4Addr, LocalAddresses[id]);
}
uint IOC_IN = 0x80000000;
uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
ssdpSession.Client.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
ssdpSession.BeginReceive(new AsyncCallback(OnReceiveSink), new object[] { ssdpSession, localEndPoint });
SSDPSessions[ssdpSession] = ssdpSession;
}
catch (Exception) { }
}
}
public void Start()
{
var version = ServiceType.Assembly.GetName().Version;
var versionStr = version.Major + "." + version.Minor;
var ssdpMsg = Encoding.UTF8.GetBytes(string.Format(SSDP_FORMAT, ServiceType.Name, versionStr, ServerName, Port));
UdpClient udp = new UdpClient();
udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udp.Client.Bind(new IPEndPoint(IPAddress.Any, Port));
udp.JoinMulticastGroup(SSDP_ENDPOINT.Address);
IsStopped = false;
var thread = new Thread(() =>
{
try
{
while (!IsStopped)
{
udp.Send(ssdpMsg, ssdpMsg.Length, SSDP_ENDPOINT);
Thread.Sleep(Interval);
}
}
catch
{ }
finally
{
try { udp.Close(); }
catch { }
}
});
thread.IsBackground = true;
thread.Start();
}
public ProsthesisTelemetryReceiver(Logger logger)
{
mLogger = logger;
mUDPReceiver = new UdpClient(ProsthesisCore.ProsthesisConstants.kTelemetryPort);
mUDPReceiver.JoinMulticastGroup(IPAddress.Parse(ProsthesisCore.ProsthesisConstants.kMulticastGroupAddress));
mTelemetryReceiver = new System.Threading.Thread(RunThread);
}
public Chat()
{
_multicastAddress = IPAddress.Parse("239.0.0.222");
_udpClient = new UdpClient();
_udpClient.JoinMulticastGroup(_multicastAddress);
_remoteEp = new IPEndPoint(_multicastAddress, 2222);
}
private void BackgroundListener()
{
IPEndPoint bindingEndpoint = new IPEndPoint(IPAddress.Any, _endPoint.Port);
using (UdpClient client = new UdpClient())
{
client.ExclusiveAddressUse = false;
client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
client.Client.Bind(bindingEndpoint);
client.JoinMulticastGroup(_endPoint.Address);
bool keepRunning = true;
while (keepRunning)
{
try
{
IPEndPoint remote = new IPEndPoint(IPAddress.Any, _endPoint.Port);
byte[] buffer = client.Receive(ref remote);
lock (this)
{
DataReceived(this, new MulticastDataReceivedEventArgs(remote, buffer));
}
}
catch (ThreadAbortException)
{
keepRunning = false;
Thread.ResetAbort();
}
}
client.DropMulticastGroup(_endPoint.Address);
}
}
/* Methods */
/// <summary>
/// UDP multicast provider constructor
/// </summary>
/// <param name="lcm">LCM object</param>
/// <param name="up">URL parser object</param>
public UDPMulticastProvider(LCM lcm, URLParser up)
{
this.lcm = lcm;
string[] addrport = up.Get("network", DEFAULT_NETWORK).Split(':');
inetAddr = Dns.GetHostEntry(addrport[0]).AddressList[0];
inetPort = Int32.Parse(addrport[1]);
inetEP = new IPEndPoint(inetAddr, inetPort);
sock = new UdpClient();
sock.MulticastLoopback = true;
sock.ExclusiveAddressUse = false;
sock.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
sock.Client.Bind(new IPEndPoint(IPAddress.Any, inetPort));
int ttl = up.Get("ttl", DEFAULT_TTL);
if (ttl == 0)
{
Console.Error.WriteLine("LCM: TTL set to zero, traffic will not leave localhost.");
}
else if (ttl > 1)
{
Console.Error.WriteLine("LCM: TTL set to > 1... That's almost never correct!");
}
else
{
Console.Error.WriteLine("LCM: TTL set to 1.");
}
sock.Ttl = (short) ttl;
sock.JoinMulticastGroup(inetAddr);
}
public bool Start()
{
try
{
//_logger.Debug(String.Format("Joining multicast group {0}:{1}", _multicastAddress, _port));
_udpClient = new UdpClient();
_udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_udpClient.ExclusiveAddressUse = false;
_endPoint = new IPEndPoint(IPAddress.Any, _port);
_udpClient.Client.Bind(_endPoint);
_udpClient.JoinMulticastGroup(IPAddress.Parse(_multicastAddress), IPAddress.Parse(_localAddress));
//_logger.Debug(String.Format("\tJoined multicast group {0}:{1} successfully", _multicastAddress, _port));
_isRunning = true;
Receive();
}
catch (Exception ex)
{
//_logger.Error(String.Format("\tFailed to join multicast group {0}:{1}", _multicastAddress, _port), ex);
}
return _isRunning;
}
public void MulticastListen()
{
Console.WriteLine("Reciever Start");
UdpClient receiveUdp = new UdpClient(this.port);
try
{
receiveUdp.JoinMulticastGroup(this.multicastIP, 10);
}
catch (SocketException e)
{
Console.WriteLine(e.Message.ToString());
}
IPEndPoint remoteHost = null;
while (true)
{
try
{
byte[] bytes = receiveUdp.Receive(ref remoteHost);
string str = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
Console.WriteLine(str);
}
catch
{
Console.WriteLine("Reciever Close");
break;
}
}
}
public Networking_UDPMultiOut(int port)
{
client = new UdpClient();
IPAddress multicastaddress = IPAddress.Parse("238.0.0.222");
client.JoinMulticastGroup(multicastaddress);
remoteep = new IPEndPoint(multicastaddress, port);
}
public static UpnpService Start( params IUpnpHandler[] handlers )
{
UdpClient udp = new UdpClient(UPNP_PORT);
udp.JoinMulticastGroup(UPNP_ADDR);
UpnpService service = new UpnpService(udp, handlers);
service.Accept();
return service;
}
public CommunicationHandler()
{
_client = new UdpClient(3007);
_client.EnableBroadcast = true;
_client.JoinMulticastGroup(IPAddress.Parse("224.109.108.107"));
_client.BeginReceive(HandleClientPacketReceived, _client);
CommsCallback = null;
}
public void Start()
{
IPEndPoint bindingEndpoint = new IPEndPoint(IPAddress.Any, _endPoint.Port);
_udpClient = new UdpClient {ExclusiveAddressUse = false};
_udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_udpClient.Client.Bind(bindingEndpoint);
_udpClient.JoinMulticastGroup(_endPoint.Address, _timeToLive);
}
public void Start()
{
udpClient = new UdpClient(portClient);
udpClient.JoinMulticastGroup(multcastAddress);
ipEndPoint = new IPEndPoint(multcastAddress, portServer);
thread = new Thread(Send);
thread.IsBackground = true;
thread.Start();
}
//Todo: should probably be removed:
/*
public MulticastReceiver(IIpConfig IpConf, IUPnPConfig upnpconf)
{
/*
_UUID = IpConf.GUID;
_cacheexpire = upnpconf.cacheExpire;
_localip = IpConf.IP;
_tcpport = IpConf.TCPPort;
SetupMulticastReceiver();
}*/
private static void SetupMulticastReceiver()
{
recClient = new UdpClient();
recIPep = new IPEndPoint(IPAddress.Any, multicastPort);
recClient.Client.Bind(recIPep);
recClient.JoinMulticastGroup(multicastIp);
}
public Server(ServerForm serverForm)
{
this.serverForm = serverForm;
client = new UdpClient(port);
multicastAddress = IPAddress.Parse("239.0.0.222");
ipEndPoint = new IPEndPoint(multicastAddress, 2222);
client.JoinMulticastGroup(multicastAddress);
}
public UdpClientContext()
{
BeginReceiveUPDserver = new AsyncCallback(OnBeginReceiveUPDserverFinished);
UdpServerSearcher = new UdpClient(BroadcastServer.Port, AddressFamily.InterNetwork);
UdpServerSearcher.JoinMulticastGroup(BroadcastServer.Address, 1); //1 router hops for just local network
UdpServerSearcher.BeginReceive(BeginReceiveUPDserver, null);
}
public DiscoveryServer(ILog log, string host, int port)
{
this.log = log;
subscriber = new UdpClient(port);
IPAddress addr = IPAddress.Parse(host);
subscriber.JoinMulticastGroup(addr);
subscriber.BeginReceive(ReceiveCallback, subscriber);
log.Log(LogLevel.Info, "Starting Discovery Server");
}
public void ConnectTo(string address, int port)
{
this.address = address;
this.port = port;
multicastIP = IPAddress.Parse(address);
udpClient = new UdpClient();
udpClient.JoinMulticastGroup(multicastIP);
endPoint = new IPEndPoint(multicastIP, port);
}
public RealTimeDataAccess(string multicastAddress, int dataPort)
{
_multicastAddr = multicastAddress;
_udpClient = new UdpClient();
_udpIpEndPoint = new IPEndPoint(IPAddress.Any, dataPort);
_udpClient.Client.Bind(_udpIpEndPoint);
_udpClient.JoinMulticastGroup(IPAddress.Parse(multicastAddress));
}
public DetectorPlotDataAccess(string multicastAddress, int dataPort)
{
_multicastAddress = multicastAddress;
_ipEndPoint = new IPEndPoint(IPAddress.Any, dataPort);
_udpClient = new UdpClient();
_udpClient.Client.Bind(_ipEndPoint);
_udpClient.JoinMulticastGroup(IPAddress.Parse(multicastAddress));
}
static Helper()
{
Client = new UdpClient {ExclusiveAddressUse = false};
Client.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
Client.ExclusiveAddressUse = false;
Client.Client.Bind(new IPEndPoint(IPAddress.Any, 10020));
Client.JoinMulticastGroup(IPAddress.Parse("224.5.23.2"));
Spinner = true;
InitializeData();
}
public void SetConnect()
{
udpClient = new UdpClient(portServer);
udpClient.JoinMulticastGroup(multcastAddress);
ipEndPoint = new IPEndPoint(IPAddress.Any, 0);
thread = new Thread(Receive);
thread.IsBackground = true;
thread.Start();
}
/// <summary>
/// listen to the group
/// </summary>
/// <param name="owner">"this" in most case</param>
/// <param name="dgGetMsg">handles message arriving</param>
public void StartListen(System.Windows.Forms.Control owner, Action <string> dgGetMsg)
{
Owner = owner;
DgGetMsg = dgGetMsg;
IsListening = true;
UdpClient = new System.Net.Sockets.UdpClient(UDPPort);
UdpClient.JoinMulticastGroup(GroupIP);
thUDPListener = new System.Threading.Thread(ListenHandler);
thUDPListener.Start();
}
public DiscoveryManager()
{
ActivityServices = new List<ServiceInfo>();
DiscoveryType = DiscoveryType.WSDiscovery;
#if ANDROID
_messageId = Guid.NewGuid().ToString();
_udpClient = new UdpClient(WsDiscoveryPort);
_udpClient.JoinMulticastGroup(IPAddress.Parse(WsDiscoveryIPAddress));
_udpClient.BeginReceive(HandleRequest, _udpClient);
#endif
}
protected override void DoInitilize()
{
remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
udpClient = IpV6 ? new UdpClient(Port, AddressFamily.InterNetworkV6) : new UdpClient(Port);
udpClient.Client.ReceiveBufferSize = BufferSize;
if (!String.IsNullOrEmpty(Address))
{
udpClient.JoinMulticastGroup(IPAddress.Parse(Address));
}
Task.Factory.StartNew(Start);
}
public FeiQIM(int Port)
{
msgdt.Columns.Add(new DataColumn("ip", System.Type.GetType("System.String")));
msgdt.Columns.Add(new DataColumn("msg", System.Type.GetType("System.String")));
msgdt.Columns.Add(new DataColumn("msgid", System.Type.GetType("System.String")));
if (!FunctionUtils.checkPort(Port.ToString()))
{
throw new Exception("端口被占用");
}
else
{
UdpClient = new System.Net.Sockets.UdpClient(Port);
UdpClient.JoinMulticastGroup(GroupIP);
//BroadcastOnLine();
}
}
protected override EventResult OnConnectBusy()
{
/* 処理中のオブジェクトを全て開放する */
if (udp_client_ != null)
{
udp_client_.Close();
udp_client_ = null;
}
var addr_family = (devp_.AddressFamily.Value == AddressFamilyType.IPv6) ? (AddressFamily.InterNetworkV6) : (AddressFamily.InterNetwork);
/* === Local Setting === */
try {
switch (devp_.LocalBindMode.Value)
{
case BindModeType.NotBind:
local_ep_ = null;
local_ep_text_ = "";
udp_client_ = new System.Net.Sockets.UdpClient(addr_family);
break;
case BindModeType.INADDR_ANY:
local_ep_ = new IPEndPoint((addr_family == AddressFamily.InterNetworkV6) ? (IPAddress.IPv6Any) : (IPAddress.Any), (ushort)devp_.LocalPortNo.Value);
local_ep_text_ = string.Format("INADDR_ANY:{0:G}", devp_.LocalPortNo.Value.ToString());
udp_client_ = new System.Net.Sockets.UdpClient(local_ep_);
break;
case BindModeType.SelectAddress:
local_ep_ = new IPEndPoint(devp_.LocalIpAddress.Value, (int)devp_.LocalPortNo.Value);
local_ep_text_ = string.Format("{0:G}:{1:G}", local_ep_.Address.ToString(), local_ep_.Port.ToString());
udp_client_ = new System.Net.Sockets.UdpClient(local_ep_);
break;
default:
return(EventResult.Error);
}
/* 生成したエンドポイントが設定しているアドレスファミリーと異なる場合はエラー */
if ((local_ep_ != null) && (local_ep_.AddressFamily != addr_family))
{
return(EventResult.Error);
}
} catch {
return(EventResult.Error);
}
/* === Remote Setting === */
try {
switch (devp_.RemoteAddressType.Value)
{
case AddressType.Unicast:
remote_ep_ = new IPEndPoint(devp_.RemoteIpAddress.Value, (int)devp_.RemotePortNo.Value);
break;
case AddressType.Broadcast:
udp_client_.EnableBroadcast = true;
remote_ep_ = new IPEndPoint(IPAddress.Broadcast, (int)devp_.RemotePortNo.Value);
break;
case AddressType.Multicast:
remote_ep_ = new IPEndPoint(devp_.RemoteIpAddress.Value, (int)devp_.RemotePortNo.Value);
break;
default:
return(EventResult.Error);
}
remote_ep_text_ = string.Format("{0:G}:{1:G}", remote_ep_.Address.ToString(), remote_ep_.Port.ToString());
/* 生成したエンドポイントが設定しているアドレスファミリーと異なる場合はエラー */
if ((remote_ep_ != null) && (remote_ep_.AddressFamily != addr_family))
{
return(EventResult.Error);
}
} catch {
return(EventResult.Error);
}
/* Unicast - TTL */
if (devp_.Unicast_TTL.Value)
{
udp_client_.Ttl = (byte)devp_.Unicast_TTL_Value.Value;
}
/* Multicast - TTL */
if (devp_.Multicast_TTL.Value)
{
if (devp_.AddressFamily.Value == AddressFamilyType.IPv6)
{
udp_client_.Client.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.MulticastTimeToLive, (byte)devp_.Multicast_TTL_Value.Value);
}
else
{
udp_client_.Client.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, (byte)devp_.Multicast_TTL_Value.Value);
}
}
/* Multicast - Loopback */
if (devp_.Multicast_Loopback.Value)
{
udp_client_.MulticastLoopback = devp_.Multicast_Loopback.Value;
}
/* Multicast Interface */
var nic_index = -1;
if (devp_.Multicast_Interface.Value)
{
var nics = NetworkInterface.GetAllNetworkInterfaces();
if ((nics != null) && (nics.Length > 0))
{
for (var nic_index_temp = 0; nic_index_temp < nics.Length; nic_index_temp++)
{
if (nics[nic_index_temp].Id == devp_.Multicast_Interface_Value.Value)
{
nic_index = nic_index_temp;
break;
}
}
}
}
/* Multicast - Group */
if (devp_.Multicast_GroupAddress.Value)
{
IPAddress ipaddr;
foreach (var ipaddr_text in devp_.Multicast_GroupAddressList.Value)
{
if ((IPAddress.TryParse(ipaddr_text, out ipaddr)) && (ipaddr.AddressFamily == addr_family))
{
if (nic_index >= 0)
{
udp_client_.JoinMulticastGroup(nic_index, ipaddr);
}
else
{
udp_client_.JoinMulticastGroup(ipaddr);
}
}
}
}
return(EventResult.Success);
}
internal void InitializeUDPDetector()
{
if (NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.Enabled)
{
{
// UDP szerver indítása
List <int> listeningPorts = NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.BroadcastListeningPorts;
if (listeningPorts.Count > 0)
{
if (NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.DetectionMode == UDPDetectionModeEnum.Multicast)
{
Action <AddressFamily, string> initMulticastUdpClient = ((a, ip) =>
{
IPEndPoint broadcastEp = null;
System.Net.Sockets.UdpClient udpClient = null;
foreach (int port in listeningPorts)
{
try
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, trying to initialize broadcast detector on port {0} ({1}).", port, a.ToString()));
}
IPAddress multicastAddress = IPAddress.Parse(ip); // (239.0.0.222)
broadcastEp = new IPEndPoint(a == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, port);
udpClient = new System.Net.Sockets.UdpClient(a);
udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udpClient.ExclusiveAddressUse = false;
udpClient.Client.Bind(broadcastEp);
udpClient.EnableBroadcast = true;
udpClient.MulticastLoopback = true;
udpClient.AllowNatTraversal(true);
udpClient.JoinMulticastGroup(multicastAddress);
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, broadcast detector initialized on port {0} ({1}).", port, a.ToString()));
}
break;
}
catch (Exception ex)
{
if (LOGGER.IsErrorEnabled)
{
LOGGER.Error(string.Format("CONNECTION_MANAGER, failed to initialize broadcast detector on port {0} ({1}). Reason: {2}", port, a.ToString(), ex.Message), ex);
}
}
}
if (udpClient != null)
{
BroadcastServer server = new BroadcastServer(broadcastEp, udpClient);
mBroadcastServers.Add(server);
server.BeginReceive();
}
});
if (!string.IsNullOrEmpty(NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv4MulticastAddress))
{
initMulticastUdpClient(AddressFamily.InterNetwork, NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv4MulticastAddress);
}
if (NetworkManager.Instance.InternalConfiguration.Settings.EnableIPV6 && !string.IsNullOrEmpty(NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv6MulticastAddress))
{
initMulticastUdpClient(AddressFamily.InterNetworkV6, NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv6MulticastAddress);
}
}
if (NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.DetectionMode == UDPDetectionModeEnum.Broadcast)
{
Action <AddressFamily> initUdpClient = (a =>
{
IPEndPoint broadcastEp = null;
System.Net.Sockets.UdpClient udpClient = null;
foreach (int port in listeningPorts)
{
try
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, trying to initialize broadcast detector on port {0} ({1}).", port, a.ToString()));
}
broadcastEp = new IPEndPoint(a == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, port);
udpClient = new System.Net.Sockets.UdpClient(broadcastEp);
udpClient.EnableBroadcast = true;
udpClient.AllowNatTraversal(true);
if (a == AddressFamily.InterNetwork)
{
udpClient.DontFragment = true;
}
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, broadcast detector initialized on port {0} ({1}).", port, a.ToString()));
}
break;
}
catch (Exception ex)
{
if (LOGGER.IsErrorEnabled)
{
LOGGER.Error(string.Format("CONNECTION_MANAGER, failed to initialize broadcast detector on port {0} ({1}). Reason: {2}", port, a.ToString(), ex.Message), ex);
}
}
}
if (udpClient != null)
{
BroadcastServer server = new BroadcastServer(broadcastEp, udpClient);
mBroadcastServers.Add(server);
server.BeginReceive();
}
});
initUdpClient(AddressFamily.InterNetwork);
if (NetworkManager.Instance.InternalConfiguration.Settings.EnableIPV6)
{
initUdpClient(AddressFamily.InterNetworkV6);
}
}
}
}
{
// UDP üzenetek szétszórása a hálózatba
List <int> targetPorts = NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.BroadcastTargetPorts;
if (targetPorts.Count > 0)
{
AddressEndPoint[] addressEps = null;
AddressEndPoint[] ipEps = null;
if (NetworkManager.Instance.InternalLocalhost.NATGatewayCollection.NATGateways.Count > 0)
{
addressEps = new AddressEndPoint[NetworkManager.Instance.InternalLocalhost.NATGatewayCollection.NATGateways.Count];
for (int i = 0; i < addressEps.Length; i++)
{
addressEps[i] = NetworkManager.Instance.InternalLocalhost.NATGatewayCollection.NATGateways[i].EndPoint;
}
}
if (NetworkManager.Instance.InternalLocalhost.TCPServerCollection.TCPServers.Count > 0)
{
ipEps = new AddressEndPoint[NetworkManager.Instance.InternalLocalhost.TCPServerCollection.TCPServers.Count];
for (int i = 0; i < ipEps.Length; i++)
{
ipEps[i] = NetworkManager.Instance.InternalLocalhost.TCPServerCollection.TCPServers[i].EndPoint;
}
}
if (addressEps != null || ipEps != null)
{
using (MemoryStream ms = new MemoryStream())
{
{
UdpBroadcastMessage message = new UdpBroadcastMessage(NetworkManager.Instance.InternalLocalhost.Id,
NetworkManager.Instance.InternalLocalhost.NetworkContext.Name, addressEps, ipEps);
MessageFormatter <UdpBroadcastMessage> formatter = new MessageFormatter <UdpBroadcastMessage>();
formatter.Write(ms, message);
ms.Position = 0;
}
// multicast
if (NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.DetectionMode == UDPDetectionModeEnum.Multicast)
{
// multicast
foreach (int port in targetPorts)
{
Action <AddressFamily, string> sendMulticastUdpClient = ((a, ip) =>
{
using (System.Net.Sockets.UdpClient udpClient = new System.Net.Sockets.UdpClient(a))
{
udpClient.MulticastLoopback = true;
udpClient.EnableBroadcast = true;
udpClient.AllowNatTraversal(true);
try
{
IPAddress multicastaddress = IPAddress.Parse(ip);
udpClient.JoinMulticastGroup(multicastaddress);
IPEndPoint remoteEp = new IPEndPoint(multicastaddress, port);
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, sending multicast message on port {0}. ({1})", port, a.ToString()));
}
udpClient.Send(ms.ToArray(), Convert.ToInt32(ms.Length), remoteEp);
udpClient.DropMulticastGroup(multicastaddress);
}
catch (Exception ex)
{
if (LOGGER.IsErrorEnabled)
{
LOGGER.Error(string.Format("CONNECTION_MANAGER, failed to send multicast message ({0}). Reason: {1}", a.ToString(), ex.Message));
}
}
}
});
if (!string.IsNullOrEmpty(NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv4MulticastAddress))
{
sendMulticastUdpClient(AddressFamily.InterNetwork, NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv4MulticastAddress);
}
if (NetworkManager.Instance.InternalConfiguration.Settings.EnableIPV6 && !string.IsNullOrEmpty(NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv6MulticastAddress))
{
sendMulticastUdpClient(AddressFamily.InterNetworkV6, NetworkManager.Instance.InternalConfiguration.NetworkPeering.UDPDetection.IPv6MulticastAddress);
}
}
}
else
{
// broadcast
using (System.Net.Sockets.UdpClient udpClient = new System.Net.Sockets.UdpClient())
{
udpClient.MulticastLoopback = false;
udpClient.EnableBroadcast = true;
udpClient.AllowNatTraversal(true);
udpClient.DontFragment = true;
foreach (int port in targetPorts)
{
try
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info(string.Format("CONNECTION_MANAGER, sending broadcast message on port {0}.", port));
}
udpClient.Send(ms.ToArray(), Convert.ToInt32(ms.Length), new IPEndPoint(IPAddress.Broadcast, port));
}
catch (Exception ex)
{
if (LOGGER.IsErrorEnabled)
{
LOGGER.Error(string.Format("CONNECTION_MANAGER, failed to send broadcast message. Reason: {0}", ex.Message));
}
}
}
}
}
}
}
else
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("CONNECTION_MANAGER, both of list NAT gateways and TCP servers are empties for broadcast detection.");
}
}
}
else
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("CONNECTION_MANAGER, no target udp port definied for broadcast detection.");
}
}
}
}
else
{
if (LOGGER.IsInfoEnabled)
{
LOGGER.Info("CONNECTION_MANAGER, broadcast detection disabled.");
}
}
}
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);
}
}
}