private bool GetIsForwardingEnabled()
{
string[] paths = new string[]
{
// /proc/sys/net/ipv4/conf/<name>/forwarding
Path.Join(NetworkFiles.Ipv4ConfigFolder, _linuxNetworkInterface.Name, NetworkFiles.ForwardingFileName),
// Fall back to global forwarding config /proc/sys/net/ipv4/ip_forward
NetworkFiles.Ipv4GlobalForwardingFile
};
for (int i = 0; i < paths.Length; i++)
{
// Actual layout is specific to kernel version and it could change over time.
// If the kernel version we're running on doesn't have this files we don't want to fail, but instead continue. We've hit this exceptions in Windows Subsystem for Linux in the past.
// Also the /proc directory may not be mounted or accessible for other reasons. Therefore we catch these potential exceptions and return false instead.
try
{
return(StringParsingHelpers.ParseRawIntFile(paths[i]) == 1);
}
catch (IOException) { }
catch (UnauthorizedAccessException) { }
}
return(false);
}
internal LinuxNetworkInterfaceSystemProperties()
{
if (File.Exists(NetworkFiles.Ipv4RouteFile))
{
try
{
IPv4Routes = File.ReadAllLines(NetworkFiles.Ipv4RouteFile);
}
catch (UnauthorizedAccessException)
{
}
}
if (File.Exists(NetworkFiles.Ipv6RouteFile))
{
try
{
IPv6Routes = File.ReadAllLines(NetworkFiles.Ipv6RouteFile);
}
catch (UnauthorizedAccessException)
{
}
}
try
{
string resolverConfig = File.ReadAllText(NetworkFiles.EtcResolvConfFile);
DnsSuffix = StringParsingHelpers.ParseDnsSuffixFromResolvConfFile(resolverConfig);
DnsAddresses = new InternalIPAddressCollection(StringParsingHelpers.ParseDnsAddressesFromResolvConfFile(resolverConfig));
}
catch (Exception e) when(e is FileNotFoundException || e is UnauthorizedAccessException)
{
}
}
private bool GetIsForwardingEnabled()
{
// /proc/sys/net/ipv4/conf/<name>/forwarding
string path = Path.Combine(NetworkFiles.Ipv4ConfigFolder, _linuxNetworkInterface.Name, NetworkFiles.ForwardingFileName);
return(StringParsingHelpers.ParseRawIntFile(path) == 1);
}
private IPAddressCollection GetWinsServerAddresses()
{
List <IPAddress> internalCollection
= StringParsingHelpers.ParseWinsServerAddressesFromSmbConfFile(NetworkFiles.SmbConfFile);
return(new InternalIPAddressCollection(internalCollection));
}
// /proc/net/route contains some information about gateway addresses,
// and seperates the information about by each interface.
public GatewayIPAddressInformationCollection GetGatewayAddresses()
{
List <GatewayIPAddressInformation> innerCollection
= StringParsingHelpers.ParseGatewayAddressesFromRouteFile(NetworkFiles.Ipv4RouteFile, _linuxNetworkInterface.Name);
return(new GatewayIPAddressInformationCollection(innerCollection));
}
private IPAddressCollection GetDhcpServerAddresses()
{
List <IPAddress> internalCollection
= StringParsingHelpers.ParseDhcpServerAddressesFromLeasesFile(NetworkFiles.DHClientLeasesFile, _linuxNetworkInterface.Name);
return(new InternalIPAddressCollection(internalCollection));
}
public LinuxIPGlobalStatistics(bool ipv4)
{
if (ipv4)
{
_table = StringParsingHelpers.ParseIPv4GlobalStatisticsFromSnmpFile(NetworkFiles.SnmpV4StatsFile);
_numRoutes = StringParsingHelpers.ParseNumRoutesFromRouteFile(NetworkFiles.Ipv4RouteFile);
_numInterfaces = StringParsingHelpers.ParseNumIPInterfaces(NetworkFiles.Ipv4ConfigFolder);
}
else
{
_table = StringParsingHelpers.ParseIPv6GlobalStatisticsFromSnmp6File(NetworkFiles.SnmpV6StatsFile);
_numRoutes = StringParsingHelpers.ParseNumRoutesFromRouteFile(NetworkFiles.Ipv6RouteFile);
_numInterfaces = StringParsingHelpers.ParseNumIPInterfaces(NetworkFiles.Ipv6ConfigFolder);
// /proc/sys/net/ipv6/conf/default/forwarding
string forwardingConfigFile = Path.Combine(NetworkFiles.Ipv6ConfigFolder,
NetworkFiles.DefaultNetworkInterfaceFileName,
NetworkFiles.ForwardingFileName);
_table.Forwarding = StringParsingHelpers.ParseRawIntFile(forwardingConfigFile) == 1;
// snmp6 does not include Default TTL info. Read it from snmp.
_table.DefaultTtl = StringParsingHelpers.ParseDefaultTtlFromFile(NetworkFiles.SnmpV4StatsFile);
}
_numIPAddresses = GetNumIPAddresses();
}
public LinuxIPInterfaceStatistics(string name)
{
_table = StringParsingHelpers.ParseInterfaceStatisticsTableFromFile(NetworkFiles.InterfaceListingFile, name);
// sys/class/net/<interfacename>/tx_queue_len
string transmitQueueLengthFilePath = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.TransmitQueueLengthFileName);
_transmitQueueLength = StringParsingHelpers.ParseRawIntFile(transmitQueueLengthFilePath);
}
private static bool GetSupportsMulticast(string name)
{
// /sys/class/net/<interface_name>/flags
string path = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.FlagsFileName);
Interop.LinuxNetDeviceFlags flags = (Interop.LinuxNetDeviceFlags)StringParsingHelpers.ParseRawHexFileAsInt(path);
return((flags & Interop.LinuxNetDeviceFlags.IFF_MULTICAST) == Interop.LinuxNetDeviceFlags.IFF_MULTICAST);
}
public LinuxTcpStatistics(bool ipv4)
{
_table = StringParsingHelpers.ParseTcpGlobalStatisticsFromSnmpFile(NetworkFiles.SnmpV4StatsFile);
string sockstatFile = ipv4 ? NetworkFiles.SockstatFile : NetworkFiles.Sockstat6File;
string protoName = ipv4 ? "TCP" : "TCP6";
_currentConnections = StringParsingHelpers.ParseNumSocketConnections(sockstatFile, protoName);
}
private IPAddressCollection GetDhcpServerAddresses()
{
List <IPAddress> internalCollection = new List <IPAddress>();
StringParsingHelpers.ParseDhcpServerAddressesFromLeasesFile(internalCollection, NetworkFiles.DHClientLeasesFile, _linuxNetworkInterface.Name);
StringParsingHelpers.ParseDhcpServerAddressesFromLeasesFile(internalCollection, string.Format(NetworkFiles.DHClientInterfaceLeasesFile, _linuxNetworkInterface.Name), _linuxNetworkInterface.Name);
StringParsingHelpers.ParseDhcpServerAddressesFromLeasesFile(internalCollection, string.Format(NetworkFiles.DHClientSecondaryInterfaceLeasesFile, _linuxNetworkInterface.Name), _linuxNetworkInterface.Name);
return(new InternalIPAddressCollection(internalCollection));
}
private static string?GetDnsSuffix()
{
try
{
return(StringParsingHelpers.ParseDnsSuffixFromResolvConfFile(File.ReadAllText(NetworkFiles.EtcResolvConfFile)));
}
catch (FileNotFoundException)
{
return(null);
}
}
private static IPAddressCollection?GetDnsAddresses()
{
try
{
List <IPAddress> internalAddresses = StringParsingHelpers.ParseDnsAddressesFromResolvConfFile(File.ReadAllText(NetworkFiles.EtcResolvConfFile));
return(new InternalIPAddressCollection(internalAddresses));
}
catch (FileNotFoundException)
{
return(null);
}
}
private static long?GetSpeed(string name)
{
try
{
string path = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.SpeedFileName);
return(StringParsingHelpers.ParseRawLongFile(path));
}
catch (Exception) // Ignore any problems accessing or parsing the file.
{
return(null);
}
}
private static long?GetSpeed(string name)
{
try
{
string path = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.SpeedFileName);
return(StringParsingHelpers.ParseRawLongFile(path));
}
catch (IOException) // Some interfaces may give an "Invalid argument" error when opening this file.
{
return(null);
}
}
public LinuxUdpStatistics(bool ipv4)
{
if (ipv4)
{
_table = StringParsingHelpers.ParseUdpv4GlobalStatisticsFromSnmpFile(NetworkFiles.SnmpV4StatsFile);
_udpListeners = StringParsingHelpers.ParseNumSocketConnections(NetworkFiles.SockstatFile, "UDP");
}
else
{
_table = StringParsingHelpers.ParseUdpv6GlobalStatisticsFromSnmp6File(NetworkFiles.SnmpV6StatsFile);
_udpListeners = StringParsingHelpers.ParseNumSocketConnections(NetworkFiles.Sockstat6File, "UDP6");
}
}
private static long?GetSpeed(string name)
{
try
{
string path = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.SpeedFileName);
long megabitsPerSecond = StringParsingHelpers.ParseRawLongFile(path);
return(megabitsPerSecond == -1
? megabitsPerSecond
: megabitsPerSecond * 1_000_000); // Value must be returned in bits per second, not megabits.
}
catch (Exception) // Ignore any problems accessing or parsing the file.
{
return(null);
}
}
// /proc/net/route contains some information about gateway addresses,
// and separates the information about by each interface.
public GatewayIPAddressInformationCollection GetGatewayAddresses(LinuxNetworkInterface.LinuxNetworkInterfaceSystemProperties systemProperties)
{
List <GatewayIPAddressInformation> collection = new List <GatewayIPAddressInformation>();
if (systemProperties.IPv4Routes != null)
{
StringParsingHelpers.ParseIPv4GatewayAddressesFromRouteFile(collection, systemProperties.IPv4Routes, _linuxNetworkInterface.Name);
}
if (systemProperties.IPv6Routes != null)
{
StringParsingHelpers.ParseIPv6GatewayAddressesFromRouteFile(collection, systemProperties.IPv6Routes, _linuxNetworkInterface.Name, _linuxNetworkInterface.Index);
}
return(new GatewayIPAddressInformationCollection(collection));
}
// /proc/net/route contains some information about gateway addresses,
// and separates the information about by each interface.
public GatewayIPAddressInformationCollection GetGatewayAddresses()
{
List <GatewayIPAddressInformation> collection = new List <GatewayIPAddressInformation>();
if (File.Exists(NetworkFiles.Ipv4RouteFile))
{
StringParsingHelpers.ParseIPv4GatewayAddressesFromRouteFile(collection, NetworkFiles.Ipv4RouteFile, _linuxNetworkInterface.Name);
}
if (File.Exists(NetworkFiles.Ipv6RouteFile))
{
StringParsingHelpers.ParseIPv6GatewayAddressesFromRouteFile(collection, NetworkFiles.Ipv6RouteFile, _linuxNetworkInterface.Name, _linuxNetworkInterface.Index);
}
return(new GatewayIPAddressInformationCollection(collection));
}
private static bool?GetSupportsMulticast(string name)
{
// /sys/class/net/<interface_name>/flags
string path = Path.Combine(NetworkFiles.SysClassNetFolder, name, NetworkFiles.FlagsFileName);
if (File.Exists(path))
{
try
{
Interop.LinuxNetDeviceFlags flags = (Interop.LinuxNetDeviceFlags)StringParsingHelpers.ParseRawHexFileAsInt(path);
return((flags & Interop.LinuxNetDeviceFlags.IFF_MULTICAST) == Interop.LinuxNetDeviceFlags.IFF_MULTICAST);
}
catch (Exception) // Ignore any problems accessing or parsing the file.
{
}
}
return(null);
}
public override IPEndPoint[] GetActiveUdpListeners()
{
return(StringParsingHelpers.ParseActiveUdpListenersFromFiles(Socket.OSSupportsIPv4 ? NetworkFiles.Udp4ConnectionsFile : null,
Socket.OSSupportsIPv6 ? NetworkFiles.Udp6ConnectionsFile : null));
}
private static string GetDnsSuffix()
{
return(StringParsingHelpers.ParseDnsSuffixFromResolvConfFile(NetworkFiles.EtcResolvConfFile));
}
public override TcpConnectionInformation[] GetActiveTcpConnections()
{
return(StringParsingHelpers.ParseActiveTcpConnectionsFromFiles(Socket.OSSupportsIPv4 ? NetworkFiles.Tcp4ConnectionsFile : null,
Socket.OSSupportsIPv6 ? NetworkFiles.Tcp6ConnectionsFile : null));
}
private static IPAddressCollection GetDnsAddresses()
{
List <IPAddress> internalAddresses = StringParsingHelpers.ParseDnsAddressesFromResolvConfFile(NetworkFiles.EtcResolvConfFile);
return(new InternalIPAddressCollection(internalAddresses));
}
public override TcpConnectionInformation[] GetActiveTcpConnections()
{
return(StringParsingHelpers.ParseActiveTcpConnectionsFromFiles(NetworkFiles.Tcp4ConnectionsFile, NetworkFiles.Tcp6ConnectionsFile));
}
private int GetMtu()
{
string path = path = Path.Combine(NetworkFiles.SysClassNetFolder, _linuxNetworkInterface.Name, NetworkFiles.MtuFileName);
return(StringParsingHelpers.ParseRawIntFile(path));
}
public override IPEndPoint[] GetActiveUdpListeners()
{
return(StringParsingHelpers.ParseActiveUdpListenersFromFiles(NetworkFiles.Udp4ConnectionsFile, NetworkFiles.Udp6ConnectionsFile));
}
// The table is a fairly large struct (108 bytes), pass it by reference
public LinuxIcmpV4Statistics()
{
_table = StringParsingHelpers.ParseIcmpv4FromSnmpFile(NetworkFiles.SnmpV4StatsFile);
}