private void CheckNetworkInterfaceStatuses(object sender, EventArgs e)
{
lock (_interfaceHandlers)
{
NetworkInterfaceInformation[] interfaceInfos = NetworkInterfaceInformation.GetAllNetworkInterfaces();
foreach (NetworkInterfaceInformation interfaceInfo in interfaceInfos)
{
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Loopback)
{
continue;
}
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Tunnel)
{
continue;
}
int index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
NetworkInterfaceHandler interfaceHandler;
_interfaceHandlers.TryGetValue(index, out interfaceHandler);
if (interfaceHandler != null)
{
if (interfaceInfo.OperationalStatus == OperationalStatus.Up)
{
interfaceHandler.Enable();
}
else
{
interfaceHandler.Disable();
}
}
}
}
}
private void CheckNetworkInterfaceStatuses(Dictionary <int, NetworkInterfaceHandler> interfaceHandlers)
{
lock (interfaceHandlers)
{
if (interfaceHandlers != _interfaceHandlers)
{
return;
}
HashSet <NetworkInterfaceHandler> handlers = new HashSet <NetworkInterfaceHandler>(_interfaceHandlers.Values);
NetworkInterfaceInformation[] interfaceInfos = NetworkInterfaceInformation.GetAllNetworkInterfaces();
foreach (NetworkInterfaceInformation interfaceInfo in interfaceInfos)
{
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Loopback)
{
continue;
}
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Tunnel)
{
continue;
}
int index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
NetworkInterfaceHandler interfaceHandler;
_interfaceHandlers.TryGetValue(index, out interfaceHandler);
if (interfaceHandler == null)
{
var networkInterface = new NetworkInterface(interfaceInfo);
index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
interfaceHandler = new NetworkInterfaceHandler(this, networkInterface);
_interfaceHandlers.Add(index, interfaceHandler);
OnNetworkInterfaceAdded(networkInterface);
interfaceHandler.StartBrowse(_serviceTypes.Select(st => new Name(st.ToLower() + ".local.")));
}
if (interfaceInfo.OperationalStatus == OperationalStatus.Up)
{
interfaceHandler.Enable();
}
else
{
interfaceHandler.Disable();
}
handlers.Remove(interfaceHandler);
}
foreach (NetworkInterfaceHandler handler in handlers)
{
_interfaceHandlers.Remove(handler.Index);
handler.Disable();
OnNetworkInterfaceRemoved(handler.NetworkInterface);
}
}
}
/// <summary>
/// Get the network interface by index
/// </summary>
/// <param name="index">Index of the network interface</param>
/// <returns>Network interface</returns>
public static NetworkInterface Get(int index)
{
int i = 0;
foreach (NetworkInterface iface in NetworkInterface.GetAllNetworkInterfaces())
{
if (iface.NetworkInterfaceType != NetworkInterfaceType.Loopback && i++ == index)
{
return(iface);
}
}
throw new ArgumentOutOfRangeException(nameof(index), "Invalid network interface");
}
private void StartBrowsing()
{
if (IsBrowsing)
{
return;
}
IsBrowsing = true;
if (SynchronizationContext == null)
{
SynchronizationContext = SynchronizationContext.Current;
}
_interfaceHandlers = new Dictionary <int, NetworkInterfaceHandler>();
NetworkInterfaceInformation[] interfaceInfos = NetworkInterfaceInformation.GetAllNetworkInterfaces();
foreach (NetworkInterfaceInformation interfaceInfo in interfaceInfos)
{
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Loopback)
{
continue;
}
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Tunnel)
{
continue;
}
var networkInterface = new NetworkInterface(interfaceInfo);
var e = new InterfaceDetectedEventArgs(networkInterface)
{
Add = true
};
OnInterfaceDetect(e);
if (e.Add)
{
int index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
_interfaceHandlers.Add(index, new NetworkInterfaceHandler(this, networkInterface));
}
}
NetworkChange.NetworkAddressChanged += CheckNetworkInterfaceStatuses;
CheckNetworkInterfaceStatuses(null, null);
}
private void CheckNetworkInterfaceStatuses(object sender, EventArgs e)
{
lock (_interfaceHandlers)
{
HashSet <NetworkInterfaceHandler> handlers = new HashSet <NetworkInterfaceHandler>(_interfaceHandlers.Values);
NetworkInterfaceInformation[] interfaceInfos = NetworkInterfaceInformation.GetAllNetworkInterfaces();
foreach (NetworkInterfaceInformation interfaceInfo in interfaceInfos)
{
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Loopback)
{
continue;
}
if (interfaceInfo.NetworkInterfaceType == NetworkInterfaceType.Tunnel)
{
continue;
}
int index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
NetworkInterfaceHandler interfaceHandler;
_interfaceHandlers.TryGetValue(index, out interfaceHandler);
if (interfaceHandler == null)
{
var networkInterface = new NetworkInterface(interfaceInfo);
index = interfaceInfo.GetIPProperties().GetIPv4Properties().Index;
interfaceHandler = new NetworkInterfaceHandler(this, networkInterface);
_interfaceHandlers.Add(index, interfaceHandler);
}
if (interfaceInfo.OperationalStatus == OperationalStatus.Up)
{
interfaceHandler.Enable();
}
else
{
interfaceHandler.Disable();
}
handlers.Remove(interfaceHandler);
}
foreach (NetworkInterfaceHandler handler in handlers)
{
handler.Disable();
}
}
}
public void DotNetInterfacesShouldEqualJavaInterfaces()
{
List <InterfaceInfo> dotnetInterfaces = GetInfos(MNetworkInterface.GetAllNetworkInterfaces());
List <InterfaceInfo> javaInterfaces = GetInfos(JNetworkInterface.NetworkInterfaces);
Console.WriteLine("Mono interfaces:");
foreach (InterfaceInfo inf in dotnetInterfaces)
{
Console.WriteLine(inf);
}
Console.WriteLine("Java interfaces:");
foreach (InterfaceInfo inf in javaInterfaces)
{
Console.WriteLine(inf);
}
Assert.IsNotNull(dotnetInterfaces, "#1.1");
Assert.IsTrue(dotnetInterfaces.Count > 0, "#1.2");
Assert.IsNotNull(javaInterfaces, "#2.1");
Assert.IsTrue(javaInterfaces.Count > 0, "#2.2");
Assert.AreEqual(dotnetInterfaces.Count, javaInterfaces.Count, "#3.1");
int counter = 4;
foreach (InterfaceInfo inf in dotnetInterfaces)
{
counter++;
Assert.IsNotNull(inf, String.Format("#{0}.1", counter));
Assert.IsFalse(String.IsNullOrEmpty(inf.Name), String.Format("#{0}.2", counter));
Assert.IsTrue(javaInterfaces.Contains(inf), "#{0}.3 ({1} not found in Java interfaces)", counter, inf.Name);
Console.WriteLine("Interface {0}: passed", inf.Name);
}
}
/// <summary>
/// Report the IP address of the network interface(s)
/// </summary>
/// <param name="builder">String builder to write to</param>
/// <param name="iface">Optional network interface</param>
/// <param name="index">Index of the network interface</param>
public static async ValueTask Report(StringBuilder builder, NetworkInterface iface, int index)
{
if (iface == null)
{
int i = 0;
foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
{
if (item.NetworkInterfaceType != NetworkInterfaceType.Loopback && (index < 0 || index == i))
{
await Report(builder, item, i ++);
}
}
}
else
{
if (NetworkInterface.GetAllNetworkInterfaces().Count(item => item.NetworkInterfaceType != NetworkInterfaceType.Loopback) > 1)
{
// Add labels if there is more than one available network interface
builder.Append($"Interface {index}: ");
}
if (iface.Name.StartsWith('w'))
{
// WiFi interface
if (iface.OperationalStatus != OperationalStatus.Down)
{
UnicastIPAddressInformation ipInfo = (from unicastAddress in iface.GetIPProperties().UnicastAddresses
where unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork
select unicastAddress).FirstOrDefault();
if (ipInfo != null)
{
bool isAccessPoint = await AccessPoint.IsEnabled();
builder.AppendLine($"WiFi module is {(isAccessPoint ? "providing access point" : "connected to access point")}, IP address {ipInfo.Address}");
}
else
{
builder.AppendLine("WiFi module is idle");
}
}
else
{
builder.AppendLine("WiFi module is disabled");
}
}
else
{
// Ethernet interface
IPAddress configuredIP = await DHCP.GetConfiguredIPAddress(iface.Name);
if (iface.OperationalStatus == OperationalStatus.Up)
{
IPAddress actualIP = (from unicastAddress in iface.GetIPProperties().UnicastAddresses
where unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork
select unicastAddress.Address).FirstOrDefault() ?? IPAddress.Any;
builder.AppendLine($"Ethernet is enabled, configured IP address: {configuredIP}, actual IP address: {actualIP}");
}
else
{
builder.AppendLine($"Ethernet is disabled, configured IP address: {configuredIP}, actual IP address: 0.0.0.0");
}
}
}
}