|
@@ -1,2008 +0,0 @@
|
|
|
-using System;
|
|
|
-using System.Collections.Generic;
|
|
|
-using System.IO;
|
|
|
-using System.Net;
|
|
|
-using System.Net.Sockets;
|
|
|
-using System.Numerics;
|
|
|
-using System.Text.RegularExpressions;
|
|
|
-
|
|
|
-namespace Emby.Server.Implementations.Networking.IPNetwork
|
|
|
-{
|
|
|
- /// <summary>
|
|
|
- /// IP Network utility class.
|
|
|
- /// Use IPNetwork.Parse to create instances.
|
|
|
- /// </summary>
|
|
|
- public class IPNetwork : IComparable<IPNetwork>
|
|
|
- {
|
|
|
-
|
|
|
- #region properties
|
|
|
-
|
|
|
- //private uint _network;
|
|
|
- private BigInteger _ipaddress;
|
|
|
- private AddressFamily _family;
|
|
|
- //private uint _netmask;
|
|
|
- //private uint _broadcast;
|
|
|
- //private uint _firstUsable;
|
|
|
- //private uint _lastUsable;
|
|
|
- //private uint _usable;
|
|
|
- private byte _cidr;
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region accessors
|
|
|
-
|
|
|
- private BigInteger _network
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- var uintNetwork = this._ipaddress & this._netmask;
|
|
|
- return uintNetwork;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Network address
|
|
|
- /// </summary>
|
|
|
- public IPAddress Network => IPNetwork.ToIPAddress(this._network, this._family);
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Address Family
|
|
|
- /// </summary>
|
|
|
- public AddressFamily AddressFamily => this._family;
|
|
|
-
|
|
|
- private BigInteger _netmask => IPNetwork.ToUint(this._cidr, this._family);
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Netmask
|
|
|
- /// </summary>
|
|
|
- public IPAddress Netmask => IPNetwork.ToIPAddress(this._netmask, this._family);
|
|
|
-
|
|
|
- private BigInteger _broadcast
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
-
|
|
|
- int width = this._family == System.Net.Sockets.AddressFamily.InterNetwork ? 4 : 16;
|
|
|
- var uintBroadcast = this._network + this._netmask.PositiveReverse(width);
|
|
|
- return uintBroadcast;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Broadcast address
|
|
|
- /// </summary>
|
|
|
- public IPAddress Broadcast
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- if (this._family == System.Net.Sockets.AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return IPNetwork.ToIPAddress(this._broadcast, this._family);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// First usable IP adress in Network
|
|
|
- /// </summary>
|
|
|
- public IPAddress FirstUsable
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- var fisrt = this._family == System.Net.Sockets.AddressFamily.InterNetworkV6
|
|
|
- ? this._network
|
|
|
- : (this.Usable <= 0) ? this._network : this._network + 1;
|
|
|
- return IPNetwork.ToIPAddress(fisrt, this._family);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Last usable IP adress in Network
|
|
|
- /// </summary>
|
|
|
- public IPAddress LastUsable
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
- var last = this._family == System.Net.Sockets.AddressFamily.InterNetworkV6
|
|
|
- ? this._broadcast
|
|
|
- : (this.Usable <= 0) ? this._network : this._broadcast - 1;
|
|
|
- return IPNetwork.ToIPAddress(last, this._family);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Number of usable IP adress in Network
|
|
|
- /// </summary>
|
|
|
- public BigInteger Usable
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
-
|
|
|
- if (this._family == System.Net.Sockets.AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- return this.Total;
|
|
|
- }
|
|
|
- byte[] mask = new byte[] { 0xff, 0xff, 0xff, 0xff, 0x00 };
|
|
|
- var bmask = new BigInteger(mask);
|
|
|
- var usableIps = (_cidr > 30) ? 0 : ((bmask >> _cidr) - 1);
|
|
|
- return usableIps;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Number of IP adress in Network
|
|
|
- /// </summary>
|
|
|
- public BigInteger Total
|
|
|
- {
|
|
|
- get
|
|
|
- {
|
|
|
-
|
|
|
- int max = this._family == System.Net.Sockets.AddressFamily.InterNetwork ? 32 : 128;
|
|
|
- var count = BigInteger.Pow(2, (max - _cidr));
|
|
|
- return count;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// The CIDR netmask notation
|
|
|
- /// </summary>
|
|
|
- public byte Cidr => this._cidr;
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region constructor
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
-
|
|
|
- IPNetwork(BigInteger ipaddress, AddressFamily family, byte cidr)
|
|
|
- {
|
|
|
-
|
|
|
- int maxCidr = family == System.Net.Sockets.AddressFamily.InterNetwork ? 32 : 128;
|
|
|
- if (cidr > maxCidr)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(cidr));
|
|
|
- }
|
|
|
-
|
|
|
- this._ipaddress = ipaddress;
|
|
|
- this._family = family;
|
|
|
- this._cidr = cidr;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region parsers
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100 - 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork Parse(string ipaddress, string netmask)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork = null;
|
|
|
- IPNetwork.InternalParse(false, ipaddress, netmask, out ipnetwork);
|
|
|
- return ipnetwork;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100/24
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork Parse(string ipaddress, byte cidr)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork = null;
|
|
|
- IPNetwork.InternalParse(false, ipaddress, cidr, out ipnetwork);
|
|
|
- return ipnetwork;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork Parse(IPAddress ipaddress, IPAddress netmask)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork = null;
|
|
|
- IPNetwork.InternalParse(false, ipaddress, netmask, out ipnetwork);
|
|
|
- return ipnetwork;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.0.1/24
|
|
|
- /// 192.168.0.1 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.0.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.0.1
|
|
|
- /// End : 192.168.0.254
|
|
|
- /// Broadcast : 192.168.0.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="network"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork Parse(string network)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork = null;
|
|
|
- IPNetwork.InternalParse(false, network, out ipnetwork);
|
|
|
- return ipnetwork;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region TryParse
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100 - 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryParse(string ipaddress, string netmask, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork2 = null;
|
|
|
- IPNetwork.InternalParse(true, ipaddress, netmask, out ipnetwork2);
|
|
|
- bool parsed = (ipnetwork2 != null);
|
|
|
- ipnetwork = ipnetwork2;
|
|
|
- return parsed;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100/24
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryParse(string ipaddress, byte cidr, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork2 = null;
|
|
|
- IPNetwork.InternalParse(true, ipaddress, cidr, out ipnetwork2);
|
|
|
- bool parsed = (ipnetwork2 != null);
|
|
|
- ipnetwork = ipnetwork2;
|
|
|
- return parsed;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.0.1/24
|
|
|
- /// 192.168.0.1 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.0.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.0.1
|
|
|
- /// End : 192.168.0.254
|
|
|
- /// Broadcast : 192.168.0.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="network"></param>
|
|
|
- /// <param name="ipnetwork"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryParse(string network, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork2 = null;
|
|
|
- IPNetwork.InternalParse(true, network, out ipnetwork2);
|
|
|
- bool parsed = (ipnetwork2 != null);
|
|
|
- ipnetwork = ipnetwork2;
|
|
|
- return parsed;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.0.1/24
|
|
|
- /// 192.168.0.1 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.0.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.0.1
|
|
|
- /// End : 192.168.0.254
|
|
|
- /// Broadcast : 192.168.0.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <param name="ipnetwork"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryParse(IPAddress ipaddress, IPAddress netmask, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork ipnetwork2 = null;
|
|
|
- IPNetwork.InternalParse(true, ipaddress, netmask, out ipnetwork2);
|
|
|
- bool parsed = (ipnetwork2 != null);
|
|
|
- ipnetwork = ipnetwork2;
|
|
|
- return parsed;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region InternalParse
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100 - 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- private static void InternalParse(bool tryParse, string ipaddress, string netmask, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(ipaddress))
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(netmask))
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(netmask));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- IPAddress ip = null;
|
|
|
- bool ipaddressParsed = IPAddress.TryParse(ipaddress, out ip);
|
|
|
- if (ipaddressParsed == false)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("ipaddress");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- IPAddress mask = null;
|
|
|
- bool netmaskParsed = IPAddress.TryParse(netmask, out mask);
|
|
|
- if (netmaskParsed == false)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("netmask");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- IPNetwork.InternalParse(tryParse, ip, mask, out ipnetwork);
|
|
|
- }
|
|
|
-
|
|
|
- private static void InternalParse(bool tryParse, string network, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(network))
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- network = Regex.Replace(network, @"[^0-9a-fA-F\.\/\s\:]+", "");
|
|
|
- network = Regex.Replace(network, @"\s{2,}", " ");
|
|
|
- network = network.Trim();
|
|
|
- string[] args = network.Split(new char[] { ' ', '/' });
|
|
|
- byte cidr = 0;
|
|
|
- if (args.Length == 1)
|
|
|
- {
|
|
|
-
|
|
|
- if (IPNetwork.TryGuessCidr(args[0], out cidr))
|
|
|
- {
|
|
|
- IPNetwork.InternalParse(tryParse, args[0], cidr, out ipnetwork);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("network");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (byte.TryParse(args[1], out cidr))
|
|
|
- {
|
|
|
- IPNetwork.InternalParse(tryParse, args[0], cidr, out ipnetwork);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- IPNetwork.InternalParse(tryParse, args[0], args[1], out ipnetwork);
|
|
|
- return;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100 255.255.255.0
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- private static void InternalParse(bool tryParse, IPAddress ipaddress, IPAddress netmask, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipaddress == null)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (netmask == null)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(netmask));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var uintIpAddress = IPNetwork.ToBigInteger(ipaddress);
|
|
|
- bool parsed = IPNetwork.TryToCidr(netmask, out var cidr2);
|
|
|
- if (parsed == false)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("netmask");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
- byte cidr = (byte)cidr2;
|
|
|
-
|
|
|
- var ipnet = new IPNetwork(uintIpAddress, ipaddress.AddressFamily, cidr);
|
|
|
- ipnetwork = ipnet;
|
|
|
-
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.168.100/24
|
|
|
- ///
|
|
|
- /// Network : 192.168.168.0
|
|
|
- /// Netmask : 255.255.255.0
|
|
|
- /// Cidr : 24
|
|
|
- /// Start : 192.168.168.1
|
|
|
- /// End : 192.168.168.254
|
|
|
- /// Broadcast : 192.168.168.255
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- private static void InternalParse(bool tryParse, string ipaddress, byte cidr, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(ipaddress))
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- IPAddress ip = null;
|
|
|
- bool ipaddressParsed = IPAddress.TryParse(ipaddress, out ip);
|
|
|
- if (ipaddressParsed == false)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("ipaddress");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- IPAddress mask = null;
|
|
|
- bool parsedNetmask = IPNetwork.TryToNetmask(cidr, ip.AddressFamily, out mask);
|
|
|
- if (parsedNetmask == false)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("cidr");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- IPNetwork.InternalParse(tryParse, ip, mask, out ipnetwork);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region converters
|
|
|
-
|
|
|
- #region ToUint
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert an ipadress to decimal
|
|
|
- /// 0.0.0.0 -> 0
|
|
|
- /// 0.0.1.0 -> 256
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static BigInteger ToBigInteger(IPAddress ipaddress)
|
|
|
- {
|
|
|
- IPNetwork.InternalToBigInteger(false, ipaddress, out var uintIpAddress);
|
|
|
- return (BigInteger)uintIpAddress;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert an ipadress to decimal
|
|
|
- /// 0.0.0.0 -> 0
|
|
|
- /// 0.0.1.0 -> 256
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryToBigInteger(IPAddress ipaddress, out BigInteger? uintIpAddress)
|
|
|
- {
|
|
|
- IPNetwork.InternalToBigInteger(true, ipaddress, out var uintIpAddress2);
|
|
|
- bool parsed = (uintIpAddress2 != null);
|
|
|
- uintIpAddress = uintIpAddress2;
|
|
|
- return parsed;
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static void InternalToBigInteger(bool tryParse, IPAddress ipaddress, out BigInteger? uintIpAddress)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipaddress == null)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
- uintIpAddress = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- byte[] bytes = ipaddress.GetAddressBytes();
|
|
|
- /// 20180217 lduchosal
|
|
|
- /// code impossible to reach, GetAddressBytes returns either 4 or 16 bytes length addresses
|
|
|
- /// if (bytes.Length != 4 && bytes.Length != 16) {
|
|
|
- /// if (tryParse == false) {
|
|
|
- /// throw new ArgumentException("bytes");
|
|
|
- /// }
|
|
|
- /// uintIpAddress = null;
|
|
|
- /// return;
|
|
|
- /// }
|
|
|
-
|
|
|
- Array.Reverse(bytes);
|
|
|
- var unsigned = new List<byte>(bytes);
|
|
|
- unsigned.Add(0);
|
|
|
- uintIpAddress = new BigInteger(unsigned.ToArray());
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert a cidr to BigInteger netmask
|
|
|
- /// </summary>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static BigInteger ToUint(byte cidr, AddressFamily family)
|
|
|
- {
|
|
|
- IPNetwork.InternalToBigInteger(false, cidr, family, out var uintNetmask);
|
|
|
- return (BigInteger)uintNetmask;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert a cidr to uint netmask
|
|
|
- /// </summary>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryToUint(byte cidr, AddressFamily family, out BigInteger? uintNetmask)
|
|
|
- {
|
|
|
- IPNetwork.InternalToBigInteger(true, cidr, family, out var uintNetmask2);
|
|
|
- bool parsed = (uintNetmask2 != null);
|
|
|
- uintNetmask = uintNetmask2;
|
|
|
- return parsed;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert a cidr to uint netmask
|
|
|
- /// </summary>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static void InternalToBigInteger(bool tryParse, byte cidr, AddressFamily family, out BigInteger? uintNetmask)
|
|
|
- {
|
|
|
-
|
|
|
- if (family == AddressFamily.InterNetwork && cidr > 32)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(cidr));
|
|
|
- }
|
|
|
- uintNetmask = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (family == AddressFamily.InterNetworkV6 && cidr > 128)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(cidr));
|
|
|
- }
|
|
|
- uintNetmask = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (family != AddressFamily.InterNetwork
|
|
|
- && family != AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new NotSupportedException(family.ToString());
|
|
|
- }
|
|
|
- uintNetmask = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (family == AddressFamily.InterNetwork)
|
|
|
- {
|
|
|
-
|
|
|
- uintNetmask = cidr == 0 ? 0 : 0xffffffff << (32 - cidr);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var mask = new BigInteger(new byte[] {
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0x00
|
|
|
- });
|
|
|
-
|
|
|
- var masked = cidr == 0 ? 0 : mask << (128 - cidr);
|
|
|
- byte[] m = masked.ToByteArray();
|
|
|
- byte[] bmask = new byte[17];
|
|
|
- int copy = m.Length > 16 ? 16 : m.Length;
|
|
|
- Array.Copy(m, 0, bmask, 0, copy);
|
|
|
- uintNetmask = new BigInteger(bmask);
|
|
|
-
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ToCidr
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert netmask to CIDR
|
|
|
- /// 255.255.255.0 -> 24
|
|
|
- /// 255.255.0.0 -> 16
|
|
|
- /// 255.0.0.0 -> 8
|
|
|
- /// </summary>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- private static void InternalToCidr(bool tryParse, BigInteger netmask, AddressFamily family, out byte? cidr)
|
|
|
- {
|
|
|
-
|
|
|
- if (!IPNetwork.InternalValidNetmask(netmask, family))
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("netmask");
|
|
|
- }
|
|
|
- cidr = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- byte cidr2 = IPNetwork.BitsSet(netmask, family);
|
|
|
- cidr = cidr2;
|
|
|
- return;
|
|
|
-
|
|
|
- }
|
|
|
- /// <summary>
|
|
|
- /// Convert netmask to CIDR
|
|
|
- /// 255.255.255.0 -> 24
|
|
|
- /// 255.255.0.0 -> 16
|
|
|
- /// 255.0.0.0 -> 8
|
|
|
- /// </summary>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static byte ToCidr(IPAddress netmask)
|
|
|
- {
|
|
|
- IPNetwork.InternalToCidr(false, netmask, out var cidr);
|
|
|
- return (byte)cidr;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert netmask to CIDR
|
|
|
- /// 255.255.255.0 -> 24
|
|
|
- /// 255.255.0.0 -> 16
|
|
|
- /// 255.0.0.0 -> 8
|
|
|
- /// </summary>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryToCidr(IPAddress netmask, out byte? cidr)
|
|
|
- {
|
|
|
- IPNetwork.InternalToCidr(true, netmask, out var cidr2);
|
|
|
- bool parsed = (cidr2 != null);
|
|
|
- cidr = cidr2;
|
|
|
- return parsed;
|
|
|
- }
|
|
|
-
|
|
|
- private static void InternalToCidr(bool tryParse, IPAddress netmask, out byte? cidr)
|
|
|
- {
|
|
|
-
|
|
|
- if (netmask == null)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(netmask));
|
|
|
- }
|
|
|
- cidr = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- bool parsed = IPNetwork.TryToBigInteger(netmask, out var uintNetmask2);
|
|
|
-
|
|
|
- /// 20180217 lduchosal
|
|
|
- /// impossible to reach code.
|
|
|
- /// if (parsed == false) {
|
|
|
- /// if (tryParse == false) {
|
|
|
- /// throw new ArgumentException("netmask");
|
|
|
- /// }
|
|
|
- /// cidr = null;
|
|
|
- /// return;
|
|
|
- /// }
|
|
|
- var uintNetmask = (BigInteger)uintNetmask2;
|
|
|
-
|
|
|
- IPNetwork.InternalToCidr(tryParse, uintNetmask, netmask.AddressFamily, out var cidr2);
|
|
|
- cidr = cidr2;
|
|
|
-
|
|
|
- return;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ToNetmask
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert CIDR to netmask
|
|
|
- /// 24 -> 255.255.255.0
|
|
|
- /// 16 -> 255.255.0.0
|
|
|
- /// 8 -> 255.0.0.0
|
|
|
- /// </summary>
|
|
|
- /// <see cref="http://snipplr.com/view/15557/cidr-class-for-ipv4/"/>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPAddress ToNetmask(byte cidr, AddressFamily family)
|
|
|
- {
|
|
|
-
|
|
|
- IPAddress netmask = null;
|
|
|
- IPNetwork.InternalToNetmask(false, cidr, family, out netmask);
|
|
|
- return netmask;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Convert CIDR to netmask
|
|
|
- /// 24 -> 255.255.255.0
|
|
|
- /// 16 -> 255.255.0.0
|
|
|
- /// 8 -> 255.0.0.0
|
|
|
- /// </summary>
|
|
|
- /// <see cref="http://snipplr.com/view/15557/cidr-class-for-ipv4/"/>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryToNetmask(byte cidr, AddressFamily family, out IPAddress netmask)
|
|
|
- {
|
|
|
-
|
|
|
- IPAddress netmask2 = null;
|
|
|
- IPNetwork.InternalToNetmask(true, cidr, family, out netmask2);
|
|
|
- bool parsed = (netmask2 != null);
|
|
|
- netmask = netmask2;
|
|
|
- return parsed;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static void InternalToNetmask(bool tryParse, byte cidr, AddressFamily family, out IPAddress netmask)
|
|
|
- {
|
|
|
-
|
|
|
- if (family != AddressFamily.InterNetwork
|
|
|
- && family != AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("family");
|
|
|
- }
|
|
|
- netmask = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- /// 20180217 lduchosal
|
|
|
- /// impossible to reach code, byte cannot be negative :
|
|
|
- ///
|
|
|
- /// if (cidr < 0) {
|
|
|
- /// if (tryParse == false) {
|
|
|
- /// throw new ArgumentOutOfRangeException("cidr");
|
|
|
- /// }
|
|
|
- /// netmask = null;
|
|
|
- /// return;
|
|
|
- /// }
|
|
|
-
|
|
|
- int maxCidr = family == System.Net.Sockets.AddressFamily.InterNetwork ? 32 : 128;
|
|
|
- if (cidr > maxCidr)
|
|
|
- {
|
|
|
- if (tryParse == false)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(cidr));
|
|
|
- }
|
|
|
- netmask = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var mask = IPNetwork.ToUint(cidr, family);
|
|
|
- var netmask2 = IPNetwork.ToIPAddress(mask, family);
|
|
|
- netmask = netmask2;
|
|
|
-
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region utils
|
|
|
-
|
|
|
- #region BitsSet
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Count bits set to 1 in netmask
|
|
|
- /// </summary>
|
|
|
- /// <see cref="http://stackoverflow.com/questions/109023/best-algorithm-to-count-the-number-of-set-bits-in-a-32-bit-integer"/>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- private static byte BitsSet(BigInteger netmask, AddressFamily family)
|
|
|
- {
|
|
|
-
|
|
|
- string s = netmask.ToBinaryString();
|
|
|
- return (byte)s.Replace("0", "")
|
|
|
- .ToCharArray()
|
|
|
- .Length;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Count bits set to 1 in netmask
|
|
|
- /// </summary>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static uint BitsSet(IPAddress netmask)
|
|
|
- {
|
|
|
- var uintNetmask = IPNetwork.ToBigInteger(netmask);
|
|
|
- uint bits = IPNetwork.BitsSet(uintNetmask, netmask.AddressFamily);
|
|
|
- return bits;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ValidNetmask
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true if netmask is a valid netmask
|
|
|
- /// 255.255.255.0, 255.0.0.0, 255.255.240.0, ...
|
|
|
- /// </summary>
|
|
|
- /// <see cref="http://www.actionsnip.com/snippets/tomo_atlacatl/calculate-if-a-netmask-is-valid--as2-"/>
|
|
|
- /// <param name="netmask"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool ValidNetmask(IPAddress netmask)
|
|
|
- {
|
|
|
-
|
|
|
- if (netmask == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(netmask));
|
|
|
- }
|
|
|
- var uintNetmask = IPNetwork.ToBigInteger(netmask);
|
|
|
- bool valid = IPNetwork.InternalValidNetmask(uintNetmask, netmask.AddressFamily);
|
|
|
- return valid;
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static bool InternalValidNetmask(BigInteger netmask, AddressFamily family)
|
|
|
- {
|
|
|
-
|
|
|
- if (family != AddressFamily.InterNetwork
|
|
|
- && family != AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- throw new ArgumentException("family");
|
|
|
- }
|
|
|
-
|
|
|
- var mask = family == AddressFamily.InterNetwork
|
|
|
- ? new BigInteger(0x0ffffffff)
|
|
|
- : new BigInteger(new byte[]{
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0xff, 0xff, 0xff, 0xff,
|
|
|
- 0x00
|
|
|
- });
|
|
|
-
|
|
|
- var neg = ((~netmask) & (mask));
|
|
|
- bool isNetmask = ((neg + 1) & neg) == 0;
|
|
|
- return isNetmask;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ToIPAddress
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Transform a uint ipaddress into IPAddress object
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPAddress ToIPAddress(BigInteger ipaddress, AddressFamily family)
|
|
|
- {
|
|
|
-
|
|
|
- int width = family == AddressFamily.InterNetwork ? 4 : 16;
|
|
|
- byte[] bytes = ipaddress.ToByteArray();
|
|
|
- byte[] bytes2 = new byte[width];
|
|
|
- int copy = bytes.Length > width ? width : bytes.Length;
|
|
|
- Array.Copy(bytes, 0, bytes2, 0, copy);
|
|
|
- Array.Reverse(bytes2);
|
|
|
-
|
|
|
- byte[] sized = Resize(bytes2, family);
|
|
|
- var ip = new IPAddress(sized);
|
|
|
- return ip;
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static byte[] Resize(byte[] bytes, AddressFamily family)
|
|
|
- {
|
|
|
-
|
|
|
- if (family != AddressFamily.InterNetwork
|
|
|
- && family != AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- throw new ArgumentException("family");
|
|
|
- }
|
|
|
-
|
|
|
- int width = family == AddressFamily.InterNetwork ? 4 : 16;
|
|
|
-
|
|
|
- if (bytes.Length > width)
|
|
|
- {
|
|
|
- throw new ArgumentException("bytes");
|
|
|
- }
|
|
|
-
|
|
|
- byte[] result = new byte[width];
|
|
|
- Array.Copy(bytes, 0, result, 0, bytes.Length);
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region contains
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true if ipaddress is contained in network
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public bool Contains(IPAddress ipaddress)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipaddress == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
-
|
|
|
- if (AddressFamily != ipaddress.AddressFamily)
|
|
|
- {
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- var uintNetwork = _network;
|
|
|
- var uintBroadcast = _broadcast;
|
|
|
- var uintAddress = IPNetwork.ToBigInteger(ipaddress);
|
|
|
-
|
|
|
- bool contains = (uintAddress >= uintNetwork
|
|
|
- && uintAddress <= uintBroadcast);
|
|
|
-
|
|
|
- return contains;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true is network2 is fully contained in network
|
|
|
- /// </summary>
|
|
|
- /// <param name="network2"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public bool Contains(IPNetwork network2)
|
|
|
- {
|
|
|
-
|
|
|
- if (network2 == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network2));
|
|
|
- }
|
|
|
-
|
|
|
- var uintNetwork = _network;
|
|
|
- var uintBroadcast = _broadcast;
|
|
|
-
|
|
|
- var uintFirst = network2._network;
|
|
|
- var uintLast = network2._broadcast;
|
|
|
-
|
|
|
- bool contains = (uintFirst >= uintNetwork
|
|
|
- && uintLast <= uintBroadcast);
|
|
|
-
|
|
|
- return contains;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region overlap
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true is network2 overlap network
|
|
|
- /// </summary>
|
|
|
- /// <param name="network2"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public bool Overlap(IPNetwork network2)
|
|
|
- {
|
|
|
-
|
|
|
- if (network2 == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network2));
|
|
|
- }
|
|
|
-
|
|
|
- var uintNetwork = _network;
|
|
|
- var uintBroadcast = _broadcast;
|
|
|
-
|
|
|
- var uintFirst = network2._network;
|
|
|
- var uintLast = network2._broadcast;
|
|
|
-
|
|
|
- bool overlap =
|
|
|
- (uintFirst >= uintNetwork && uintFirst <= uintBroadcast)
|
|
|
- || (uintLast >= uintNetwork && uintLast <= uintBroadcast)
|
|
|
- || (uintFirst <= uintNetwork && uintLast >= uintBroadcast)
|
|
|
- || (uintFirst >= uintNetwork && uintLast <= uintBroadcast);
|
|
|
-
|
|
|
- return overlap;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ToString
|
|
|
-
|
|
|
- public override string ToString()
|
|
|
- {
|
|
|
- return string.Format("{0}/{1}", this.Network, this.Cidr);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region IANA block
|
|
|
-
|
|
|
- private static readonly Lazy<IPNetwork> _iana_ablock_reserved = new Lazy<IPNetwork>(() => IPNetwork.Parse("10.0.0.0/8"));
|
|
|
- private static readonly Lazy<IPNetwork> _iana_bblock_reserved = new Lazy<IPNetwork>(() => IPNetwork.Parse("172.16.0.0/12"));
|
|
|
- private static readonly Lazy<IPNetwork> _iana_cblock_reserved = new Lazy<IPNetwork>(() => IPNetwork.Parse("192.168.0.0/16"));
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 10.0.0.0/8
|
|
|
- /// </summary>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork IANA_ABLK_RESERVED1 => _iana_ablock_reserved.Value;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 172.12.0.0/12
|
|
|
- /// </summary>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork IANA_BBLK_RESERVED1 => _iana_bblock_reserved.Value;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// 192.168.0.0/16
|
|
|
- /// </summary>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork IANA_CBLK_RESERVED1 => _iana_cblock_reserved.Value;
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true if ipaddress is contained in
|
|
|
- /// IANA_ABLK_RESERVED1, IANA_BBLK_RESERVED1, IANA_CBLK_RESERVED1
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipaddress"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool IsIANAReserved(IPAddress ipaddress)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipaddress == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipaddress));
|
|
|
- }
|
|
|
-
|
|
|
- return IPNetwork.IANA_ABLK_RESERVED1.Contains(ipaddress)
|
|
|
- || IPNetwork.IANA_BBLK_RESERVED1.Contains(ipaddress)
|
|
|
- || IPNetwork.IANA_CBLK_RESERVED1.Contains(ipaddress);
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// return true if ipnetwork is contained in
|
|
|
- /// IANA_ABLK_RESERVED1, IANA_BBLK_RESERVED1, IANA_CBLK_RESERVED1
|
|
|
- /// </summary>
|
|
|
- /// <returns></returns>
|
|
|
- public bool IsIANAReserved()
|
|
|
- {
|
|
|
- return IPNetwork.IANA_ABLK_RESERVED1.Contains(this)
|
|
|
- || IPNetwork.IANA_BBLK_RESERVED1.Contains(this)
|
|
|
- || IPNetwork.IANA_CBLK_RESERVED1.Contains(this);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Subnet
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Subnet a network into multiple nets of cidr mask
|
|
|
- /// Subnet 192.168.0.0/24 into cidr 25 gives 192.168.0.0/25, 192.168.0.128/25
|
|
|
- /// Subnet 10.0.0.0/8 into cidr 9 gives 10.0.0.0/9, 10.128.0.0/9
|
|
|
- /// </summary>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public IPNetworkCollection Subnet(byte cidr)
|
|
|
- {
|
|
|
- IPNetworkCollection ipnetworkCollection = null;
|
|
|
- IPNetwork.InternalSubnet(false, this, cidr, out ipnetworkCollection);
|
|
|
- return ipnetworkCollection;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Subnet a network into multiple nets of cidr mask
|
|
|
- /// Subnet 192.168.0.0/24 into cidr 25 gives 192.168.0.0/25, 192.168.0.128/25
|
|
|
- /// Subnet 10.0.0.0/8 into cidr 9 gives 10.0.0.0/9, 10.128.0.0/9
|
|
|
- /// </summary>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public bool TrySubnet(byte cidr, out IPNetworkCollection ipnetworkCollection)
|
|
|
- {
|
|
|
- IPNetworkCollection inc = null;
|
|
|
- IPNetwork.InternalSubnet(true, this, cidr, out inc);
|
|
|
- if (inc == null)
|
|
|
- {
|
|
|
- ipnetworkCollection = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- ipnetworkCollection = inc;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static void InternalSubnet(bool trySubnet, IPNetwork network, byte cidr, out IPNetworkCollection ipnetworkCollection)
|
|
|
- {
|
|
|
-
|
|
|
- if (network == null)
|
|
|
- {
|
|
|
- if (trySubnet == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network));
|
|
|
- }
|
|
|
- ipnetworkCollection = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- int maxCidr = network._family == System.Net.Sockets.AddressFamily.InterNetwork ? 32 : 128;
|
|
|
- if (cidr > maxCidr)
|
|
|
- {
|
|
|
- if (trySubnet == false)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(cidr));
|
|
|
- }
|
|
|
- ipnetworkCollection = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (cidr < network.Cidr)
|
|
|
- {
|
|
|
- if (trySubnet == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("cidr");
|
|
|
- }
|
|
|
- ipnetworkCollection = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- ipnetworkCollection = new IPNetworkCollection(network, cidr);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Supernet
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Supernet two consecutive cidr equal subnet into a single one
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 = 192.168.0.0/23
|
|
|
- /// 10.1.0.0/16 + 10.0.0.0/16 = 10.0.0.0/15
|
|
|
- /// 192.168.0.0/24 + 192.168.0.0/25 = 192.168.0.0/24
|
|
|
- /// </summary>
|
|
|
- /// <param name="network2"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public IPNetwork Supernet(IPNetwork network2)
|
|
|
- {
|
|
|
- IPNetwork supernet = null;
|
|
|
- IPNetwork.InternalSupernet(false, this, network2, out supernet);
|
|
|
- return supernet;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Try to supernet two consecutive cidr equal subnet into a single one
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 = 192.168.0.0/23
|
|
|
- /// 10.1.0.0/16 + 10.0.0.0/16 = 10.0.0.0/15
|
|
|
- /// 192.168.0.0/24 + 192.168.0.0/25 = 192.168.0.0/24
|
|
|
- /// </summary>
|
|
|
- /// <param name="network2"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public bool TrySupernet(IPNetwork network2, out IPNetwork supernet)
|
|
|
- {
|
|
|
-
|
|
|
- IPNetwork outSupernet = null;
|
|
|
- IPNetwork.InternalSupernet(true, this, network2, out outSupernet);
|
|
|
- bool parsed = (outSupernet != null);
|
|
|
- supernet = outSupernet;
|
|
|
- return parsed;
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static void InternalSupernet(bool trySupernet, IPNetwork network1, IPNetwork network2, out IPNetwork supernet)
|
|
|
- {
|
|
|
-
|
|
|
- if (network1 == null)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network1));
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (network2 == null)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(network2));
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- if (network1.Contains(network2))
|
|
|
- {
|
|
|
- supernet = new IPNetwork(network1._network, network1._family, network1.Cidr);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (network2.Contains(network1))
|
|
|
- {
|
|
|
- supernet = new IPNetwork(network2._network, network2._family, network2.Cidr);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (network1._cidr != network2._cidr)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("cidr");
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var first = (network1._network < network2._network) ? network1 : network2;
|
|
|
- var last = (network1._network > network2._network) ? network1 : network2;
|
|
|
-
|
|
|
- /// Starting from here :
|
|
|
- /// network1 and network2 have the same cidr,
|
|
|
- /// network1 does not contain network2,
|
|
|
- /// network2 does not contain network1,
|
|
|
- /// first is the lower subnet
|
|
|
- /// last is the higher subnet
|
|
|
-
|
|
|
-
|
|
|
- if ((first._broadcast + 1) != last._network)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentOutOfRangeException(nameof(trySupernet), "TrySupernet was false while the first and last networks are not adjacent.");
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- var uintSupernet = first._network;
|
|
|
- byte cidrSupernet = (byte)(first._cidr - 1);
|
|
|
-
|
|
|
- var networkSupernet = new IPNetwork(uintSupernet, first._family, cidrSupernet);
|
|
|
- if (networkSupernet._network != first._network)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("network");
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return;
|
|
|
- }
|
|
|
- supernet = networkSupernet;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region GetHashCode
|
|
|
-
|
|
|
- public override int GetHashCode()
|
|
|
- {
|
|
|
- return string.Format("{0}|{1}|{2}",
|
|
|
- this._ipaddress.GetHashCode(),
|
|
|
- this._network.GetHashCode(),
|
|
|
- this._cidr.GetHashCode()).GetHashCode();
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region SupernetArray
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Supernet a list of subnet
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 = 192.168.0.0/23
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 + 192.168.2.0/24 + 192.168.3.0/24 = 192.168.0.0/22
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipnetworks">The IP networks</param>
|
|
|
- /// <returns></returns>
|
|
|
- public static IPNetwork[] Supernet(IPNetwork[] ipnetworks)
|
|
|
- {
|
|
|
- InternalSupernet(false, ipnetworks, out var supernet);
|
|
|
- return supernet;
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Supernet a list of subnet
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 = 192.168.0.0/23
|
|
|
- /// 192.168.0.0/24 + 192.168.1.0/24 + 192.168.2.0/24 + 192.168.3.0/24 = 192.168.0.0/22
|
|
|
- /// </summary>
|
|
|
- /// <param name="ipnetworks"></param>
|
|
|
- /// <param name="supernet"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TrySupernet(IPNetwork[] ipnetworks, out IPNetwork[] supernet)
|
|
|
- {
|
|
|
- bool supernetted = InternalSupernet(true, ipnetworks, out supernet);
|
|
|
- return supernetted;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-#if TRAVISCI
|
|
|
- public
|
|
|
-#else
|
|
|
- internal
|
|
|
-#endif
|
|
|
- static bool InternalSupernet(bool trySupernet, IPNetwork[] ipnetworks, out IPNetwork[] supernet)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipnetworks == null)
|
|
|
- {
|
|
|
- if (trySupernet == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipnetworks));
|
|
|
- }
|
|
|
- supernet = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if (ipnetworks.Length <= 0)
|
|
|
- {
|
|
|
- supernet = new IPNetwork[0];
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- var supernetted = new List<IPNetwork>();
|
|
|
- var ipns = IPNetwork.Array2List(ipnetworks);
|
|
|
- var current = IPNetwork.List2Stack(ipns);
|
|
|
- int previousCount = 0;
|
|
|
- int currentCount = current.Count;
|
|
|
-
|
|
|
- while (previousCount != currentCount)
|
|
|
- {
|
|
|
-
|
|
|
- supernetted.Clear();
|
|
|
- while (current.Count > 1)
|
|
|
- {
|
|
|
- var ipn1 = current.Pop();
|
|
|
- var ipn2 = current.Peek();
|
|
|
-
|
|
|
- IPNetwork outNetwork = null;
|
|
|
- bool success = ipn1.TrySupernet(ipn2, out outNetwork);
|
|
|
- if (success)
|
|
|
- {
|
|
|
- current.Pop();
|
|
|
- current.Push(outNetwork);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- supernetted.Add(ipn1);
|
|
|
- }
|
|
|
- }
|
|
|
- if (current.Count == 1)
|
|
|
- {
|
|
|
- supernetted.Add(current.Pop());
|
|
|
- }
|
|
|
-
|
|
|
- previousCount = currentCount;
|
|
|
- currentCount = supernetted.Count;
|
|
|
- current = IPNetwork.List2Stack(supernetted);
|
|
|
-
|
|
|
- }
|
|
|
- supernet = supernetted.ToArray();
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- private static Stack<IPNetwork> List2Stack(List<IPNetwork> list)
|
|
|
- {
|
|
|
- var stack = new Stack<IPNetwork>();
|
|
|
- list.ForEach(new Action<IPNetwork>(
|
|
|
- delegate (IPNetwork ipn)
|
|
|
- {
|
|
|
- stack.Push(ipn);
|
|
|
- }
|
|
|
- ));
|
|
|
- return stack;
|
|
|
- }
|
|
|
-
|
|
|
- private static List<IPNetwork> Array2List(IPNetwork[] array)
|
|
|
- {
|
|
|
- var ipns = new List<IPNetwork>();
|
|
|
- ipns.AddRange(array);
|
|
|
- IPNetwork.RemoveNull(ipns);
|
|
|
- ipns.Sort(new Comparison<IPNetwork>(
|
|
|
- delegate (IPNetwork ipn1, IPNetwork ipn2)
|
|
|
- {
|
|
|
- int networkCompare = ipn1._network.CompareTo(ipn2._network);
|
|
|
- if (networkCompare == 0)
|
|
|
- {
|
|
|
- int cidrCompare = ipn1._cidr.CompareTo(ipn2._cidr);
|
|
|
- return cidrCompare;
|
|
|
- }
|
|
|
- return networkCompare;
|
|
|
- }
|
|
|
- ));
|
|
|
- ipns.Reverse();
|
|
|
-
|
|
|
- return ipns;
|
|
|
- }
|
|
|
-
|
|
|
- private static void RemoveNull(List<IPNetwork> ipns)
|
|
|
- {
|
|
|
- ipns.RemoveAll(new Predicate<IPNetwork>(
|
|
|
- delegate (IPNetwork ipn)
|
|
|
- {
|
|
|
- if (ipn == null)
|
|
|
- {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- ));
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region WideSubnet
|
|
|
-
|
|
|
- public static IPNetwork WideSubnet(string start, string end)
|
|
|
- {
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(start))
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(start));
|
|
|
- }
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(end))
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(end));
|
|
|
- }
|
|
|
-
|
|
|
- if (!IPAddress.TryParse(start, out var startIP))
|
|
|
- {
|
|
|
- throw new ArgumentException("start");
|
|
|
- }
|
|
|
-
|
|
|
- if (!IPAddress.TryParse(end, out var endIP))
|
|
|
- {
|
|
|
- throw new ArgumentException("end");
|
|
|
- }
|
|
|
-
|
|
|
- if (startIP.AddressFamily != endIP.AddressFamily)
|
|
|
- {
|
|
|
- throw new NotSupportedException("MixedAddressFamily");
|
|
|
- }
|
|
|
-
|
|
|
- var ipnetwork = new IPNetwork(0, startIP.AddressFamily, 0);
|
|
|
- for (byte cidr = 32; cidr >= 0; cidr--)
|
|
|
- {
|
|
|
- var wideSubnet = IPNetwork.Parse(start, cidr);
|
|
|
- if (wideSubnet.Contains(endIP))
|
|
|
- {
|
|
|
- ipnetwork = wideSubnet;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return ipnetwork;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- public static bool TryWideSubnet(IPNetwork[] ipnetworks, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
- IPNetwork ipn = null;
|
|
|
- IPNetwork.InternalWideSubnet(true, ipnetworks, out ipn);
|
|
|
- if (ipn == null)
|
|
|
- {
|
|
|
- ipnetwork = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
- ipnetwork = ipn;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- public static IPNetwork WideSubnet(IPNetwork[] ipnetworks)
|
|
|
- {
|
|
|
- IPNetwork ipn = null;
|
|
|
- IPNetwork.InternalWideSubnet(false, ipnetworks, out ipn);
|
|
|
- return ipn;
|
|
|
- }
|
|
|
-
|
|
|
- internal static void InternalWideSubnet(bool tryWide, IPNetwork[] ipnetworks, out IPNetwork ipnetwork)
|
|
|
- {
|
|
|
-
|
|
|
- if (ipnetworks == null)
|
|
|
- {
|
|
|
- if (tryWide == false)
|
|
|
- {
|
|
|
- throw new ArgumentNullException(nameof(ipnetworks));
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- IPNetwork[] nnin = Array.FindAll(ipnetworks, new Predicate<IPNetwork>(
|
|
|
- delegate (IPNetwork ipnet)
|
|
|
- {
|
|
|
- return ipnet != null;
|
|
|
- }
|
|
|
- ));
|
|
|
-
|
|
|
- if (nnin.Length <= 0)
|
|
|
- {
|
|
|
- if (tryWide == false)
|
|
|
- {
|
|
|
- throw new ArgumentException("ipnetworks");
|
|
|
- }
|
|
|
- ipnetwork = null;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if (nnin.Length == 1)
|
|
|
- {
|
|
|
- var ipn0 = nnin[0];
|
|
|
- ipnetwork = ipn0;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- Array.Sort(nnin);
|
|
|
- var nnin0 = nnin[0];
|
|
|
- var uintNnin0 = nnin0._ipaddress;
|
|
|
-
|
|
|
- var nninX = nnin[nnin.Length - 1];
|
|
|
- var ipaddressX = nninX.Broadcast;
|
|
|
-
|
|
|
- var family = ipnetworks[0]._family;
|
|
|
- foreach (var ipnx in ipnetworks)
|
|
|
- {
|
|
|
- if (ipnx._family != family)
|
|
|
- {
|
|
|
- throw new ArgumentException("MixedAddressFamily");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- var ipn = new IPNetwork(0, family, 0);
|
|
|
- for (byte cidr = nnin0._cidr; cidr >= 0; cidr--)
|
|
|
- {
|
|
|
- var wideSubnet = new IPNetwork(uintNnin0, family, cidr);
|
|
|
- if (wideSubnet.Contains(ipaddressX))
|
|
|
- {
|
|
|
- ipn = wideSubnet;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ipnetwork = ipn;
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Print
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Print an ipnetwork in a clear representation string
|
|
|
- /// </summary>
|
|
|
- /// <returns></returns>
|
|
|
- public string Print()
|
|
|
- {
|
|
|
-
|
|
|
- var sw = new StringWriter();
|
|
|
-
|
|
|
- sw.WriteLine("IPNetwork : {0}", ToString());
|
|
|
- sw.WriteLine("Network : {0}", Network);
|
|
|
- sw.WriteLine("Netmask : {0}", Netmask);
|
|
|
- sw.WriteLine("Cidr : {0}", Cidr);
|
|
|
- sw.WriteLine("Broadcast : {0}", Broadcast);
|
|
|
- sw.WriteLine("FirstUsable : {0}", FirstUsable);
|
|
|
- sw.WriteLine("LastUsable : {0}", LastUsable);
|
|
|
- sw.WriteLine("Usable : {0}", Usable);
|
|
|
-
|
|
|
- return sw.ToString();
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region TryGuessCidr
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- ///
|
|
|
- /// Class Leading bits Default netmask
|
|
|
- /// A (CIDR /8) 00 255.0.0.0
|
|
|
- /// A (CIDR /8) 01 255.0.0.0
|
|
|
- /// B (CIDR /16) 10 255.255.0.0
|
|
|
- /// C (CIDR /24) 11 255.255.255.0
|
|
|
- ///
|
|
|
- /// </summary>
|
|
|
- /// <param name="ip"></param>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryGuessCidr(string ip, out byte cidr)
|
|
|
- {
|
|
|
-
|
|
|
- IPAddress ipaddress = null;
|
|
|
- bool parsed = IPAddress.TryParse(string.Format("{0}", ip), out ipaddress);
|
|
|
- if (parsed == false)
|
|
|
- {
|
|
|
- cidr = 0;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if (ipaddress.AddressFamily == AddressFamily.InterNetworkV6)
|
|
|
- {
|
|
|
- cidr = 64;
|
|
|
- return true;
|
|
|
- }
|
|
|
- var uintIPAddress = IPNetwork.ToBigInteger(ipaddress);
|
|
|
- uintIPAddress = uintIPAddress >> 29;
|
|
|
- if (uintIPAddress <= 3)
|
|
|
- {
|
|
|
- cidr = 8;
|
|
|
- return true;
|
|
|
- }
|
|
|
- else if (uintIPAddress <= 5)
|
|
|
- {
|
|
|
- cidr = 16;
|
|
|
- return true;
|
|
|
- }
|
|
|
- else if (uintIPAddress <= 6)
|
|
|
- {
|
|
|
- cidr = 24;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- cidr = 0;
|
|
|
- return false;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// Try to parse cidr. Have to be >= 0 and <= 32 or 128
|
|
|
- /// </summary>
|
|
|
- /// <param name="sidr"></param>
|
|
|
- /// <param name="cidr"></param>
|
|
|
- /// <returns></returns>
|
|
|
- public static bool TryParseCidr(string sidr, AddressFamily family, out byte? cidr)
|
|
|
- {
|
|
|
-
|
|
|
- byte b = 0;
|
|
|
- if (!byte.TryParse(sidr, out b))
|
|
|
- {
|
|
|
- cidr = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- IPAddress netmask = null;
|
|
|
- if (!IPNetwork.TryToNetmask(b, family, out netmask))
|
|
|
- {
|
|
|
- cidr = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- cidr = b;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region ListIPAddress
|
|
|
-
|
|
|
- public IPAddressCollection ListIPAddress()
|
|
|
- {
|
|
|
- return new IPAddressCollection(this);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- /**
|
|
|
- * Need a better way to do it
|
|
|
- *
|
|
|
-#region TrySubstractNetwork
|
|
|
-
|
|
|
- public static bool TrySubstractNetwork(IPNetwork[] ipnetworks, IPNetwork substract, out IEnumerable<IPNetwork> result) {
|
|
|
-
|
|
|
- if (ipnetworks == null) {
|
|
|
- result = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (ipnetworks.Length <= 0) {
|
|
|
- result = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (substract == null) {
|
|
|
- result = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
- var results = new List<IPNetwork>();
|
|
|
- foreach (var ipn in ipnetworks) {
|
|
|
- if (!Overlap(ipn, substract)) {
|
|
|
- results.Add(ipn);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- var collection = ipn.Subnet(substract.Cidr);
|
|
|
- var rtemp = new List<IPNetwork>();
|
|
|
- foreach(var subnet in collection) {
|
|
|
- if (subnet != substract) {
|
|
|
- rtemp.Add(subnet);
|
|
|
- }
|
|
|
- }
|
|
|
- var supernets = Supernet(rtemp.ToArray());
|
|
|
- results.AddRange(supernets);
|
|
|
- }
|
|
|
- result = results;
|
|
|
- return true;
|
|
|
- }
|
|
|
-#endregion
|
|
|
- * **/
|
|
|
-
|
|
|
- #region IComparable<IPNetwork> Members
|
|
|
-
|
|
|
- public static int Compare(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- // two null IPNetworks are equal
|
|
|
- if (ReferenceEquals(left, null) && ReferenceEquals(right, null)) return 0;
|
|
|
-
|
|
|
- // two same IPNetworks are equal
|
|
|
- if (ReferenceEquals(left, right)) return 0;
|
|
|
-
|
|
|
- // null is always sorted first
|
|
|
- if (ReferenceEquals(left, null)) return -1;
|
|
|
- if (ReferenceEquals(right, null)) return 1;
|
|
|
-
|
|
|
- // first test the network
|
|
|
- var result = left._network.CompareTo(right._network);
|
|
|
- if (result != 0) return result;
|
|
|
-
|
|
|
- // then test the cidr
|
|
|
- result = left._cidr.CompareTo(right._cidr);
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- public int CompareTo(IPNetwork other)
|
|
|
- {
|
|
|
- return Compare(this, other);
|
|
|
- }
|
|
|
-
|
|
|
- public int CompareTo(object obj)
|
|
|
- {
|
|
|
- // null is at less
|
|
|
- if (obj == null) return 1;
|
|
|
-
|
|
|
- // convert to a proper Cidr object
|
|
|
- var other = obj as IPNetwork;
|
|
|
-
|
|
|
- // type problem if null
|
|
|
- if (other == null)
|
|
|
- {
|
|
|
- throw new ArgumentException(
|
|
|
- "The supplied parameter is an invalid type. Please supply an IPNetwork type.",
|
|
|
- nameof(obj));
|
|
|
- }
|
|
|
-
|
|
|
- // perform the comparision
|
|
|
- return CompareTo(other);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region IEquatable<IPNetwork> Members
|
|
|
-
|
|
|
- public static bool Equals(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- return Compare(left, right) == 0;
|
|
|
- }
|
|
|
-
|
|
|
- public bool Equals(IPNetwork other)
|
|
|
- {
|
|
|
- return Equals(this, other);
|
|
|
- }
|
|
|
-
|
|
|
- public override bool Equals(object obj)
|
|
|
- {
|
|
|
- return Equals(this, obj as IPNetwork);
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Operators
|
|
|
-
|
|
|
- public static bool operator ==(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- return Equals(left, right);
|
|
|
- }
|
|
|
-
|
|
|
- public static bool operator !=(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- return !Equals(left, right);
|
|
|
- }
|
|
|
-
|
|
|
- public static bool operator <(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- return Compare(left, right) < 0;
|
|
|
- }
|
|
|
-
|
|
|
- public static bool operator >(IPNetwork left, IPNetwork right)
|
|
|
- {
|
|
|
- return Compare(left, right) > 0;
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- }
|
|
|
-}
|