private static Exception?TryParseStartEndFormat(string str, int separatorPos, out IPAddressRange result)
{
result = None;
var s = str.Substring(0, separatorPos).Trim();
if (!IPAddressUtility.TryParse(s, out var startAddress))
{
return(InvalidStartAddress());
}
s = str.Substring(separatorPos + 1).Trim();
if (!IPAddressUtility.TryParse(s, out var endAddress))
{
return(InvalidEndAddress());
}
var addressFamily = startAddress.AddressFamily;
if (endAddress.AddressFamily != addressFamily)
{
return(MismatchedStartEndFamily());
}
var start = new IPAddressValue(startAddress);
var end = new IPAddressValue(endAddress);
if (end.CompareTo(start) < 0)
{
return(EndLowerThanStart());
}
result = new IPAddressRange(start, end, addressFamily == AddressFamily.InterNetworkV6, 0);
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="IPAddressRange"/> class,
/// representing a range of IP addresses between <paramref name="start"/>
/// and <paramref name="end"/>, extremes included.
/// </summary>
/// <param name="start">The starting address of the range.</param>
/// <param name="end">The ending address of the range.</param>
/// <exception cref="ArgumentNullException">
/// <para><paramref name="start"/> is <see langword="null"/>.</para>
/// <para>- or -</para>
/// <para><paramref name="end"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="ArgumentException">
/// <para><paramref name="end"/> has a different <see cref="IPAddress.AddressFamily">AddressFamily</see>
/// from <paramref name="start"/>.</para>
/// <para>- or -</para>
/// <para><paramref name="end"/> is a lower address than <paramref name="start"/>,
/// i.e. the binary representation of <paramref name="end"/> in network byte order
/// is a lower number than the same representation of <paramref name="start"/>.</para>
/// </exception>
public IPAddressRange(IPAddress start, IPAddress end)
{
if (start == null)
{
throw new ArgumentNullException(nameof(start));
}
if (end == null)
{
throw new ArgumentNullException(nameof(end));
}
var startFamily = start.AddressFamily;
_isV6 = startFamily == AddressFamily.InterNetworkV6;
if (end.AddressFamily != startFamily)
{
throw MismatchedEndFamily(nameof(end));
}
_start = new IPAddressValue(start);
_end = new IPAddressValue(end);
if (_end.CompareTo(_start) < 0)
{
throw EndLowerThanStart(nameof(end));
}
_prefixLength = 0;
}
private IPAddressRange(IPAddressValue start, IPAddressValue end, bool isV6, byte prefixLength)
{
_start = start;
_end = end;
_isV6 = isV6;
_prefixLength = prefixLength;
}
/// <summary>
/// Initializes a new instance of the <see cref="IPAddressRange"/> class,
/// representing a CIDR subnet.
/// </summary>
/// <param name="baseAddress">The base address of the subnet.</param>
/// <param name="prefixLength">The prefix length of the subnet.</param>
/// <exception cref="ArgumentNullException"><paramref name="baseAddress"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">
/// <para><paramref name="prefixLength"/> is zero.</para>
/// <para>- or -</para>
/// <para><paramref name="prefixLength"/> is greater than the number of bits in
/// the binary representation of <paramref name="baseAddress"/> (32 for IPv4 addresses,
/// 128 for IPv6 addresses.)</para>
/// <para>- or -</para>
/// <para><paramref name="baseAddress"/> cannot be the base address of a subnet with a prefix length
/// equal to <paramref name="prefixLength"/>, because the remaining bits after the prefix
/// are not all zeros.</para>
/// </exception>
public IPAddressRange(IPAddress baseAddress, byte prefixLength)
{
if (baseAddress == null)
{
throw new ArgumentNullException(nameof(baseAddress));
}
byte maxPrefixLength;
if (baseAddress.AddressFamily == AddressFamily.InterNetworkV6)
{
_isV6 = true;
maxPrefixLength = 128;
}
else
{
_isV6 = false;
maxPrefixLength = 32;
}
if (prefixLength < 1 || prefixLength > maxPrefixLength)
{
throw InvalidPrefixLength(nameof(prefixLength));
}
_start = new IPAddressValue(baseAddress);
if (!_start.IsStartOfSubnet(prefixLength))
{
throw InvalidSubnetBaseAddress(nameof(baseAddress));
}
_end = _start.GetEndOfSubnet(prefixLength);
_prefixLength = prefixLength;
}
/// <summary>
/// Initializes a new instance of the <see cref="IPAddressRange"/> class,
/// representing a single IP address.
/// </summary>
/// <param name="address">The IP address.</param>
/// <exception cref="ArgumentNullException"><paramref name="address"/> is <see langword="null"/>.</exception>
public IPAddressRange(IPAddress address)
{
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
_start = _end = new IPAddressValue(address);
_isV6 = address.AddressFamily == AddressFamily.InterNetworkV6;
_prefixLength = 0;
}
/// <summary>
/// Determines whether the given <paramref name="address"/>
/// sa contained in this range.
/// </summary>
/// <param name="address">The IP address to check.</param>
/// <returns><see langword="true"/> if <paramref name="address"/>
/// is between <see cref="Start"/> and <see cref="End"/>, inclusive;
/// otherwise, <see lamgword="false"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="address"/> is <see langword="null"/>.</exception>
/// <remarks>
/// <para>This method treats IPv4 addresses and their IPv6-mapped counterparts
/// the same; that is, given a range obtained by parsing the string <c>192.168.1.0/24</c>,
/// <c>Contains(IPAddress.Parse("192.168.1.55"))</c> will return <see langword="true"/>,
/// as will <c>Contains(IPAddress.Parse("192.168.1.55").MapToIPv6())</c>. This is true
/// as well if a range is initialized with IPv6 addresses.</para>
/// </remarks>
public bool Contains(IPAddress address)
{
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
var addressValue = new IPAddressValue(address);
return(addressValue.CompareTo(_start) >= 0 &&
addressValue.CompareTo(_end) <= 0);
}
/// <summary>
/// Wrapper for grabbing a device with fallback support to retry with v1
/// </summary>
/// <param name="ipAddress"></param>
/// <returns></returns>
private Device pollDeviceFromSnmpWithFallback(IPAddressValue address)
{
AgentParameters snmpParam = createSnmpParameters(address.Community, 2);
Device device = pollDeviceFromSnmp(address.IPAddress, snmpParam);
if (device.Errors == "Request has reached maximum retries." && config.Settings.SnmpV1Fallback == true)
{
snmpParam = createSnmpParameters(address.Community, 1);
device = pollDeviceFromSnmp(address.IPAddress, snmpParam);
}
return(device);
}
/// <summary>
/// Get a single string from an ipaddress/oid via SNMP
/// </summary>
/// <param name="ipAddress"></param>
/// <param name="oid"></param>
/// <returns></returns>
public string GetSnmpStringWithFallback(IPAddressValue address, string oid)
{
AgentParameters snmpParam = createSnmpParameters(address.Community, 2);
string result = pollStringFromSnmp(address.IPAddress, snmpParam, oid);
if (result == null & config.Settings.SnmpV1Fallback == true)
{
snmpParam = createSnmpParameters(address.Community, 1);
result = pollStringFromSnmp(address.IPAddress, snmpParam, oid);
}
return(result);
}
private static Exception?TryParseSingleAddressFormat(string str, out IPAddressRange result)
{
result = None;
if (!IPAddressUtility.TryParse(str, out var address))
{
return(InvalidIPAddress());
}
var addressValue = new IPAddressValue(address);
result = new IPAddressRange(addressValue, addressValue, address.AddressFamily == AddressFamily.InterNetworkV6, 0);
return(null);
}
private static IPAddressValue CheckIP(IPAddressValue ipv)
{
var totalRetries = 3;
var retry = 0;
do
{
Ping ping = new Ping();
var result = ping.Send(ipv.IPAddress, 500);
if (result.Status == IPStatus.Success)
{
//Console.WriteLine($"Pinging {ipv.IPAddress}... Success");
retry = 9999;
return(ipv);
}
else
{
//Console.WriteLine($"Pinging {ipv.IPAddress}... Failed (Retry# {retry})");
System.Threading.Thread.Sleep(1000);
retry++;
}
} while (retry < totalRetries);
return(null);
}
/// <summary>
/// If we don't have a regex that combines Model and Version, we use this routine to check various other models
/// Including Fixed, Regex and SNMP methods for fetching valid Model/Version
/// </summary>
/// <param name="modelCheck"></param>
/// <param name="address"></param>
/// <param name="config"></param>
/// <returns></returns>
private (string model, string version) altSysVersionChecks(ModelCheck modelCheck, IPAddressValue address, Configuration config)
{
var model = "";
var version = "";
// Use a fixed model (worst case)
if (modelCheck.ModelFixed != "")
{
model = modelCheck.ModelFixed;
}
// Use a fixed Version (why would we want to, but oh well)
if (modelCheck.VersionFixed != "")
{
model = modelCheck.VersionFixed;
}
// Use a custom regex of sysVersion to grab Version
if (modelCheck.ModelRegex != "")
{
Regex r = new Regex(modelCheck.ModelRegex, RegexOptions.IgnoreCase);
var mR = r.Matches(SysVersion);
if (mR.Count > 0)
{
model = mR[0].Groups["Model"].Value;
}
}
// Use a custom regex of sysVersion to grab Version
if (modelCheck.VersionRegex != "")
{
Regex r = new Regex(modelCheck.VersionRegex, RegexOptions.IgnoreCase);
var mR = r.Matches(SysVersion);
if (mR.Count > 0)
{
version = mR[0].Groups["Version"].Value;
}
}
// Fetch Model/Version from SNMP directly if it's set
if (modelCheck.ModelSnmp != "" || modelCheck.VersionSnmp != "")
{
var snmp = new SnmpTools(config);
// Grab Model from SNMP if it's supplied
if (modelCheck.ModelSnmp != "")
{
model = snmp.GetSnmpStringWithFallback(address, modelCheck.ModelSnmp);
}
// Grab Version from SNMP if it's supplied
if (modelCheck.VersionSnmp != "")
{
version = snmp.GetSnmpStringWithFallback(address, modelCheck.VersionSnmp);
}
}
return(model, version);
}
private static Exception?TryParseCidrOrAddressNetmaskFormat(string str, int separatorPos, out IPAddressRange result)
{
result = None;
var s = str.Substring(0, separatorPos).Trim();
if (!IPAddressUtility.TryParse(s, out var address))
{
return(InvalidIPAddress());
}
var addressValue = new IPAddressValue(address);
s = str.Substring(separatorPos + 1).Trim();
if (byte.TryParse(s, NumberStyles.None, CultureInfo.InvariantCulture, out var prefixLength))
{
var maxPrefixLength = address.AddressFamily == AddressFamily.InterNetworkV6 ? 128 : 32;
if (prefixLength < 1 || prefixLength > maxPrefixLength)
{
return(InvalidPrefixLength());
}
if (!addressValue.IsStartOfSubnet(prefixLength))
{
return(InvalidSubnetBaseAddress());
}
result = new IPAddressRange(addressValue, addressValue.GetEndOfSubnet(prefixLength), address.AddressFamily == AddressFamily.InterNetworkV6, prefixLength);
return(null);
}
// Only accept a netmask for IPv4
if (address.AddressFamily != AddressFamily.InterNetwork)
{
return(InvalidPrefixLength());
}
if (!IPAddressUtility.TryParse(s, out var netmask))
{
return(InvalidPrefixLengthOrNetmask());
}
var addressFamily = address.AddressFamily;
if (netmask.AddressFamily != addressFamily)
{
return(MismatchedNetmaskAddressFamily());
}
var netmaskBytes = netmask.GetAddressBytes();
if (!TryNetmaskToCidrPrefixLength(netmaskBytes, out prefixLength))
{
return(InvalidNetmask());
}
if (!addressValue.IsStartOfSubnet(prefixLength))
{
return(InvalidSubnetBaseAddress());
}
result = new IPAddressRange(addressValue, addressValue.GetEndOfSubnet(prefixLength), false, prefixLength);
return(null);
}
