michael.heier/jellyfin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
32469b3f65
jellyfin/Emby.Server.Implementations/Networking/IPNetwork/IPNetwork.cs

2069 lines
59 KiB
C#
Raw Normal View History

Update to 3.5.2 and .net core 2.1
2018-09-12 17:26:21 +00:00
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;
using System.Numerics;
using System.Text.RegularExpressions;
namespace System.Net
{
/// <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
{
BigInteger uintNetwork = this._ipaddress & this._netmask;
return uintNetwork;
}
}
/// <summary>
/// Network address
/// </summary>
public IPAddress Network
{
get
{
return IPNetwork.ToIPAddress(this._network, this._family);
}
}
/// <summary>
/// Address Family
/// </summary>
public AddressFamily AddressFamily
{
get
{
return this._family;
}
}
private BigInteger _netmask
{
get
{
return IPNetwork.ToUint(this._cidr, this._family);
}
}
/// <summary>
/// Netmask
/// </summary>
public IPAddress Netmask
{
get
{
return IPNetwork.ToIPAddress(this._netmask, this._family);
}
}
private BigInteger _broadcast
{
get
{
int width = this._family == Sockets.AddressFamily.InterNetwork ? 4 : 16;
BigInteger uintBroadcast = this._network + this._netmask.PositiveReverse(width);
return uintBroadcast;
}
}
/// <summary>
/// Broadcast address
/// </summary>
public IPAddress Broadcast
{
get
{
if (this._family == Sockets.AddressFamily.InterNetworkV6)
{
return null;
}
return IPNetwork.ToIPAddress(this._broadcast, this._family);
}
}
/// <summary>
/// First usable IP adress in Network
/// </summary>
public IPAddress FirstUsable
{
get
{
BigInteger fisrt = this._family == 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
{
BigInteger last = this._family == 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 == Sockets.AddressFamily.InterNetworkV6)
{
return this.Total;
}
byte[] mask = new byte[] { 0xff, 0xff, 0xff, 0xff, 0x00 };
BigInteger bmask = new BigInteger(mask);
BigInteger 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 == Sockets.AddressFamily.InterNetwork ? 32 : 128;
BigInteger count = BigInteger.Pow(2, (max - _cidr));
return count;
}
}
/// <summary>
/// The CIDR netmask notation
/// </summary>
public byte Cidr
{
get
{
return this._cidr;
}
}
#endregion
#region constructor
#if TRAVISCI
public
#else
internal
#endif
Remove obsolete functions
2019-01-02 11:15:05 +00:00
IPNetwork(BigInteger ipaddress, AddressFamily family, byte cidr)
Update to 3.5.2 and .net core 2.1
2018-09-12 17:26:21 +00:00
{
int maxCidr = family == Sockets.AddressFamily.InterNetwork ? 32 : 128;
if (cidr > maxCidr)
{
throw new ArgumentOutOfRangeException("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("ipaddress");
}
ipnetwork = null;
return;
}
if (string.IsNullOrEmpty(netmask))
{
if (tryParse == false)
{
throw new ArgumentNullException("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("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("ipaddress");
}
ipnetwork = null;
return;
}
if (netmask == null)
{
if (tryParse == false)
{
throw new ArgumentNullException("netmask");
}
ipnetwork = null;
return;
}
BigInteger uintIpAddress = IPNetwork.ToBigInteger(ipaddress);
byte? cidr2 = null;
bool parsed = IPNetwork.TryToCidr(netmask, out cidr2);
if (parsed == false)
{
if (tryParse == false)
{
throw new ArgumentException("netmask");
}
ipnetwork = null;
return;
}
byte cidr = (byte)cidr2;
IPNetwork 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("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)
{
BigInteger? uintIpAddress = null;
IPNetwork.InternalToBigInteger(false, ipaddress, out 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)
{
BigInteger? uintIpAddress2 = null;
IPNetwork.InternalToBigInteger(true, ipaddress, out 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("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)
{
BigInteger? uintNetmask = null;
IPNetwork.InternalToBigInteger(false, cidr, family, out 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)
{
BigInteger? uintNetmask2 = null;
IPNetwork.InternalToBigInteger(true, cidr, family, out 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("cidr");
}
uintNetmask = null;
return;
}
if (family == AddressFamily.InterNetworkV6 && cidr > 128)
{
if (tryParse == false)
{
throw new ArgumentOutOfRangeException("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;
}
BigInteger mask = new BigInteger(new byte[] {
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
0x00
});
BigInteger 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)
{
byte? cidr = null;
IPNetwork.InternalToCidr(false, netmask, out 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)
{
byte? cidr2 = null;
IPNetwork.InternalToCidr(true, netmask, out 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("netmask");
}
cidr = null;
return;
}
BigInteger? uintNetmask2 = null;
bool parsed = IPNetwork.TryToBigInteger(netmask, out uintNetmask2);
/// 20180217 lduchosal
/// impossible to reach code.
/// if (parsed == false) {
/// if (tryParse == false) {
/// throw new ArgumentException("netmask");
/// }
/// cidr = null;
/// return;
/// }
BigInteger uintNetmask = (BigInteger)uintNetmask2;
byte? cidr2 = null;
IPNetwork.InternalToCidr(tryParse, uintNetmask, netmask.AddressFamily, out 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 == Sockets.AddressFamily.InterNetwork ? 32 : 128;
if (cidr > maxCidr)
{
if (tryParse == false)
{
throw new ArgumentOutOfRangeException("cidr");
}
netmask = null;
return;
}
BigInteger mask = IPNetwork.ToUint(cidr, family);
IPAddress 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)
{
BigInteger 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("netmask");
}
BigInteger 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
});
BigInteger 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);
IPAddress 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("ipaddress");
}
if (AddressFamily != ipaddress.AddressFamily)
{
return false;
}
BigInteger uintNetwork = _network;
BigInteger uintBroadcast = _broadcast;
BigInteger 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("network2");
}
BigInteger uintNetwork = _network;
BigInteger uintBroadcast = _broadcast;
BigInteger uintFirst = network2._network;
BigInteger 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("network2");
}
BigInteger uintNetwork = _network;
BigInteger uintBroadcast = _broadcast;
BigInteger uintFirst = network2._network;
BigInteger 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
{
get
{
return _iana_ablock_reserved.Value;
}
}
/// <summary>
/// 172.12.0.0/12
/// </summary>
/// <returns></returns>
public static IPNetwork IANA_BBLK_RESERVED1
{
get
{
return _iana_bblock_reserved.Value;
}
}
/// <summary>
/// 192.168.0.0/16
/// </summary>
/// <returns></returns>
public static IPNetwork IANA_CBLK_RESERVED1
{
get
{
return _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("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("network");
}
ipnetworkCollection = null;
return;
}
int maxCidr = network._family == Sockets.AddressFamily.InterNetwork ? 32 : 128;
if (cidr > maxCidr)
{
if (trySubnet == false)
{
throw new ArgumentOutOfRangeException("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("network1");
}
supernet = null;
return;
}
if (network2 == null)
{
if (trySupernet == false)
{
throw new ArgumentNullException("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;
}
IPNetwork first = (network1._network < network2._network) ? network1 : network2;
IPNetwork 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("network");
}
supernet = null;
return;
}
BigInteger uintSupernet = first._network;
byte cidrSupernet = (byte)(first._cidr - 1);
IPNetwork 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"></param>
/// <param name="supernet"></param>
/// <returns></returns>
public static IPNetwork[] Supernet(IPNetwork[] ipnetworks)
{
IPNetwork[] supernet;
InternalSupernet(false, ipnetworks, out 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("ipnetworks");
}
supernet = null;
return false;
}
if (ipnetworks.Length <= 0)
{
supernet = new IPNetwork[0];
return true;
}
List<IPNetwork> supernetted = new List<IPNetwork>();
List<IPNetwork> ipns = IPNetwork.Array2List(ipnetworks);
Stack<IPNetwork> current = IPNetwork.List2Stack(ipns);
int previousCount = 0;
int currentCount = current.Count;
while (previousCount != currentCount)
{
supernetted.Clear();
while (current.Count > 1)
{
IPNetwork ipn1 = current.Pop();
IPNetwork 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)
{
Stack<IPNetwork> stack = new Stack<IPNetwork>();
list.ForEach(new Action<IPNetwork>(
delegate (IPNetwork ipn)
{
stack.Push(ipn);
}
));
return stack;
}
private static List<IPNetwork> Array2List(IPNetwork[] array)
{
List<IPNetwork> 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("start");
}
if (string.IsNullOrEmpty(end))
{
throw new ArgumentNullException("end");
}
IPAddress startIP;
if (!IPAddress.TryParse(start, out startIP))
{
throw new ArgumentException("start");
}
IPAddress endIP;
if (!IPAddress.TryParse(end, out endIP))
{
throw new ArgumentException("end");
}
if (startIP.AddressFamily != endIP.AddressFamily)
{
throw new NotSupportedException("MixedAddressFamily");
}
IPNetwork ipnetwork = new IPNetwork(0, startIP.AddressFamily, 0);
for (byte cidr = 32; cidr >= 0; cidr--)
{
IPNetwork 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("ipnetworks");
}
ipnetwork = null;
return;
}
IPNetwork[] nnin = Array.FindAll<IPNetwork>(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)
{
IPNetwork ipn0 = nnin[0];
ipnetwork = ipn0;
return;
}
Array.Sort<IPNetwork>(nnin);
IPNetwork nnin0 = nnin[0];
BigInteger uintNnin0 = nnin0._ipaddress;
IPNetwork nninX = nnin[nnin.Length - 1];
IPAddress ipaddressX = nninX.Broadcast;
AddressFamily family = ipnetworks[0]._family;
foreach (var ipnx in ipnetworks)
{
if (ipnx._family != family)
{
throw new ArgumentException("MixedAddressFamily");
}
}
IPNetwork ipn = new IPNetwork(0, family, 0);
for (byte cidr = nnin0._cidr; cidr >= 0; cidr--)
{
IPNetwork 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()
{
StringWriter 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;
}
BigInteger 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 Int32 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 Int32 CompareTo(IPNetwork other)
{
return Compare(this, other);
}
public Int32 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.",
"obj");
}
// perform the comparision
return CompareTo(other);
}
#endregion
#region IEquatable<IPNetwork> Members
public static Boolean Equals(IPNetwork left, IPNetwork right)
{
return Compare(left, right) == 0;
}
public Boolean Equals(IPNetwork other)
{
return Equals(this, other);
}
public override Boolean Equals(Object obj)
{
return Equals(this, obj as IPNetwork);
}
#endregion
#region Operators
public static Boolean operator ==(IPNetwork left, IPNetwork right)
{
return Equals(left, right);
}
public static Boolean operator !=(IPNetwork left, IPNetwork right)
{
return !Equals(left, right);
}
public static Boolean operator <(IPNetwork left, IPNetwork right)
{
return Compare(left, right) < 0;
}
public static Boolean operator >(IPNetwork left, IPNetwork right)
{
return Compare(left, right) > 0;
}
#endregion
}
Remove obsolete functions
2019-01-02 11:15:05 +00:00
}
Reference in New Issue Copy Permalink