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); }