Updated with new NetManager

5 files changed, 1375 insertions, 2 deletions

diff --git a/MediaBrowser.Common/Net/INetworkManager.cs b/MediaBrowser.Common/Net/INetworkManager.cs
index f60f369d6a..a7beabbdcb 100644
--- a/MediaBrowser.Common/Net/INetworkManager.cs
+++ b/MediaBrowser.Common/Net/INetworkManager.cs
@@ -4,7 +4,7 @@ using System.Collections.Generic;
 using System.Net;
 using System.Net.NetworkInformation;
 using Microsoft.AspNetCore.Http;
-using NetworkCollection;
+using NetCollection = System.Collections.ObjectModel.Collection<MediaBrowser.Common.Net.IPObject>;
 
 namespace MediaBrowser.Common.Net
 {
@@ -130,7 +130,7 @@ namespace MediaBrowser.Common.Net
         /// Get a list of all the MAC addresses associated with active interfaces.
         /// </summary>
         /// <returns>List of MAC addresses.</returns>
-        List<PhysicalAddress> GetMacAddresses();
+        IReadOnlyCollection<PhysicalAddress> GetMacAddresses();
 
         /// <summary>
         /// Checks to see if the IP Address provided matches an interface that has a gateway.
diff --git a/MediaBrowser.Common/Net/IPHost.cs b/MediaBrowser.Common/Net/IPHost.cs
new file mode 100644
index 0000000000..80052727af
--- /dev/null
+++ b/MediaBrowser.Common/Net/IPHost.cs
@@ -0,0 +1,447 @@
+#nullable enable
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Common.Net
+{
+    /// <summary>
+    /// Object that holds a host name.
+    /// </summary>
+    public class IPHost : IPObject
+    {
+        /// <summary>
+        /// Represents an IPHost that has no value.
+        /// </summary>
+        public static readonly IPHost None = new IPHost(string.Empty, IPAddress.None);
+
+        /// <summary>
+        /// Time when last resolved.
+        /// </summary>
+        private long _lastResolved;
+
+        /// <summary>
+        /// Gets the IP Addresses, attempting to resolve the name, if there are none.
+        /// </summary>
+        private IPAddress[] _addresses;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPHost"/> class.
+        /// </summary>
+        /// <param name="name">Host name to assign.</param>
+        public IPHost(string name)
+        {
+            HostName = name ?? throw new ArgumentNullException(nameof(name));
+            _addresses = Array.Empty<IPAddress>();
+            Resolved = false;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPHost"/> class.
+        /// </summary>
+        /// <param name="name">Host name to assign.</param>
+        /// <param name="address">Address to assign.</param>
+        private IPHost(string name, IPAddress address)
+        {
+            HostName = name ?? throw new ArgumentNullException(nameof(name));
+            _addresses = new IPAddress[] { address ?? throw new ArgumentNullException(nameof(address)) };
+            Resolved = !address.Equals(IPAddress.None);
+        }
+
+        /// <summary>
+        /// Gets or sets the object's first IP address.
+        /// </summary>
+        public override IPAddress Address
+        {
+            get
+            {
+                return ResolveHost() ? this[0] : IPAddress.None;
+            }
+
+            set
+            {
+                // Not implemented.
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the object's first IP's subnet prefix.
+        /// The setter does nothing, but shouldn't raise an exception.
+        /// </summary>
+        public override byte PrefixLength
+        {
+            get
+            {
+                return (byte)(ResolveHost() ? 128 : 0);
+            }
+
+            set
+            {
+                // Not implemented.
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets timeout value before resolve required, in minutes.
+        /// </summary>
+        public byte Timeout { get; set; } = 30;
+
+        /// <summary>
+        /// Gets a value indicating whether the address has a value.
+        /// </summary>
+        public bool HasAddress
+        {
+            get
+            {
+                return _addresses.Length > 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the host name of this object.
+        /// </summary>
+        public string HostName { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether this host has attempted to be resolved.
+        /// </summary>
+        public bool Resolved { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the IP Addresses associated with this object.
+        /// </summary>
+        /// <param name="index">Index of address.</param>
+        public IPAddress this[int index]
+        {
+            get
+            {
+                ResolveHost();
+                return index >= 0 && index < _addresses.Length ? _addresses[index] : IPAddress.None;
+            }
+        }
+
+        /// <summary>
+        /// Attempts to parse the host string.
+        /// </summary>
+        /// <param name="host">Host name to parse.</param>
+        /// <param name="hostObj">Object representing the string, if it has successfully been parsed.</param>
+        /// <returns>Success result of the parsing.</returns>
+        public static bool TryParse(string host, out IPHost hostObj)
+        {
+            if (!string.IsNullOrEmpty(host))
+            {
+                // See if it's an IPv6 with port address e.g. [::1]:120.
+                int i = host.IndexOf("]:", StringComparison.OrdinalIgnoreCase);
+                if (i != -1)
+                {
+                    return TryParse(host.Remove(i - 1).TrimStart(' ', '['), out hostObj);
+                }
+                else
+                {
+                    // See if it's an IPv6 in [] with no port.
+                    i = host.IndexOf("]", StringComparison.OrdinalIgnoreCase);
+                    if (i != -1)
+                    {
+                        return TryParse(host.Remove(i - 1).TrimStart(' ', '['), out hostObj);
+                    }
+
+                    // Is it a host or IPv4 with port?
+                    string[] hosts = host.Split(':');
+
+                    if (hosts.Length > 2)
+                    {
+                        hostObj = new IPHost(string.Empty, IPAddress.None);
+                        return false;
+                    }
+
+                    // Remove port from IPv4 if it exists.
+                    host = hosts[0];
+
+                    if (string.Equals("localhost", host, StringComparison.OrdinalIgnoreCase))
+                    {
+                        hostObj = new IPHost(host, new IPAddress(Ipv4Loopback));
+                        return true;
+                    }
+
+                    if (IPNetAddress.TryParse(host, out IPNetAddress netIP))
+                    {
+                        // Host name is an ip address, so fake resolve.
+                        hostObj = new IPHost(host, netIP.Address);
+                        return true;
+                    }
+                }
+
+                // Only thing left is to see if it's a host string.
+                if (!string.IsNullOrEmpty(host))
+                {
+                    // Use regular expression as CheckHostName isn't RFC5892 compliant.
+                    // Modified from gSkinner's expression at https://stackoverflow.com/questions/11809631/fully-qualified-domain-name-validation
+                    Regex re = new Regex(@"^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){0,127}(?![0-9]*$)[a-z0-9-]+\.?)$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
+                    if (re.Match(host).Success)
+                    {
+                        hostObj = new IPHost(host);
+                        return true;
+                    }
+                }
+            }
+
+            hostObj = IPHost.None;
+            return false;
+        }
+
+        /// <summary>
+        /// Attempts to parse the host string.
+        /// </summary>
+        /// <param name="host">Host name to parse.</param>
+        /// <returns>Object representing the string, if it has successfully been parsed.</returns>
+        public static IPHost Parse(string host)
+        {
+            if (!string.IsNullOrEmpty(host) && IPHost.TryParse(host, out IPHost res))
+            {
+                return res;
+            }
+
+            throw new InvalidCastException("Host does not contain a valid value. {host}");
+        }
+
+        /// <summary>
+        /// Attempts to parse the host string, ensuring that it resolves only to a specific IP type.
+        /// </summary>
+        /// <param name="host">Host name to parse.</param>
+        /// <param name="family">Addressfamily filter.</param>
+        /// <returns>Object representing the string, if it has successfully been parsed.</returns>
+        public static IPHost Parse(string host, AddressFamily family)
+        {
+            if (!string.IsNullOrEmpty(host) && IPHost.TryParse(host, out IPHost res))
+            {
+                if (family == AddressFamily.InterNetwork)
+                {
+                    res.Remove(AddressFamily.InterNetworkV6);
+                }
+                else
+                {
+                    res.Remove(AddressFamily.InterNetwork);
+                }
+
+                return res;
+            }
+
+            throw new InvalidCastException("Host does not contain a valid value. {host}");
+        }
+
+        /// <summary>
+        /// Returns the Addresses that this item resolved to.
+        /// </summary>
+        /// <returns>IPAddress Array.</returns>
+        public IPAddress[] GetAddresses()
+        {
+            ResolveHost();
+            return _addresses;
+        }
+
+        /// <inheritdoc/>
+        public override bool Contains(IPAddress address)
+        {
+            if (address != null && !Address.Equals(IPAddress.None))
+            {
+                if (address.IsIPv4MappedToIPv6)
+                {
+                    address = address.MapToIPv4();
+                }
+
+                foreach (var addr in GetAddresses())
+                {
+                    if (address.Equals(addr))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(IPObject? other)
+        {
+            if (other is IPHost otherObj)
+            {
+                // Do we have the name Hostname?
+                if (string.Equals(otherObj.HostName, HostName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+
+                if (!ResolveHost() || !otherObj.ResolveHost())
+                {
+                    return false;
+                }
+
+                // Do any of our IP addresses match?
+                foreach (IPAddress addr in _addresses)
+                {
+                    foreach (IPAddress otherAddress in otherObj._addresses)
+                    {
+                        if (addr.Equals(otherAddress))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override bool IsIP6()
+        {
+            // Returns true if interfaces are only IP6.
+            if (ResolveHost())
+            {
+                foreach (IPAddress i in _addresses)
+                {
+                    if (i.AddressFamily != AddressFamily.InterNetworkV6)
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            // StringBuilder not optimum here.
+            string output = string.Empty;
+            if (_addresses.Length > 0)
+            {
+                bool moreThanOne = _addresses.Length > 1;
+                if (moreThanOne)
+                {
+                    output = "[";
+                }
+
+                foreach (var i in _addresses)
+                {
+                    if (Address.Equals(IPAddress.None) && Address.AddressFamily == AddressFamily.Unspecified)
+                    {
+                        output += HostName + ",";
+                    }
+                    else if (i.Equals(IPAddress.Any))
+                    {
+                        output += "Any IP4 Address,";
+                    }
+                    else if (Address.Equals(IPAddress.IPv6Any))
+                    {
+                        output += "Any IP6 Address,";
+                    }
+                    else if (i.Equals(IPAddress.Broadcast))
+                    {
+                        output += "Any Address,";
+                    }
+                    else
+                    {
+                        output += $"{i}/32,";
+                    }
+                }
+
+                output = output[0..^1];
+
+                if (moreThanOne)
+                {
+                    output += "]";
+                }
+            }
+            else
+            {
+                output = HostName;
+            }
+
+            return output;
+        }
+
+        /// <inheritdoc/>
+        public override void Remove(AddressFamily family)
+        {
+            if (ResolveHost())
+            {
+                _addresses = _addresses.Where(p => p.AddressFamily != family).ToArray();
+            }
+        }
+
+        /// <inheritdoc/>
+        public override bool Contains(IPObject address)
+        {
+            // An IPHost cannot contain another IPObject, it can only be equal.
+            return Equals(address);
+        }
+
+        /// <inheritdoc/>
+        protected override IPObject CalculateNetworkAddress()
+        {
+            var netAddr = NetworkAddressOf(this[0], PrefixLength);
+            return new IPNetAddress(netAddr.Address, netAddr.PrefixLength);
+        }
+
+        /// <summary>
+        /// Attempt to resolve the ip address of a host.
+        /// </summary>
+        /// <returns>The result of the comparison function.</returns>
+        private bool ResolveHost()
+        {
+            // When was the last time we resolved?
+            if (_lastResolved == 0)
+            {
+                _lastResolved = DateTime.Now.Ticks;
+            }
+
+            // If we haven't resolved before, or out timer has run out...
+            if ((_addresses.Length == 0 && !Resolved) || (TimeSpan.FromTicks(DateTime.Now.Ticks - _lastResolved).TotalMinutes > Timeout))
+            {
+                _lastResolved = DateTime.Now.Ticks;
+                ResolveHostInternal().GetAwaiter().GetResult();
+                Resolved = true;
+            }
+
+            return _addresses.Length > 0;
+        }
+
+        /// <summary>
+        /// Task that looks up a Host name and returns its IP addresses.
+        /// </summary>
+        /// <returns>Array of IPAddress objects.</returns>
+        private async Task ResolveHostInternal()
+        {
+            if (!string.IsNullOrEmpty(HostName))
+            {
+                // Resolves the host name - so save a DNS lookup.
+                if (string.Equals(HostName, "localhost", StringComparison.OrdinalIgnoreCase))
+                {
+                    _addresses = new IPAddress[] { new IPAddress(Ipv4Loopback), new IPAddress(Ipv6Loopback) };
+                    return;
+                }
+
+                if (Uri.CheckHostName(HostName).Equals(UriHostNameType.Dns))
+                {
+                    try
+                    {
+                        IPHostEntry ip = await Dns.GetHostEntryAsync(HostName).ConfigureAwait(false);
+                        _addresses = ip.AddressList;
+                    }
+                    catch (SocketException)
+                    {
+                        // Ignore socket errors, as the result value will just be an empty array.
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Common/Net/IPNetAddress.cs b/MediaBrowser.Common/Net/IPNetAddress.cs
new file mode 100644
index 0000000000..bcd049f3d5
--- /dev/null
+++ b/MediaBrowser.Common/Net/IPNetAddress.cs
@@ -0,0 +1,277 @@
+#nullable enable
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace MediaBrowser.Common.Net
+{
+    /// <summary>
+    /// An object that holds and IP address and subnet mask.
+    /// </summary>
+    public class IPNetAddress : IPObject
+    {
+        /// <summary>
+        /// Represents an IPNetAddress that has no value.
+        /// </summary>
+        public static readonly IPNetAddress None = new IPNetAddress(IPAddress.None);
+
+        /// <summary>
+        /// IPv4 multicast address.
+        /// </summary>
+        public static readonly IPAddress MulticastIPv4 = IPAddress.Parse("239.255.255.250");
+
+        /// <summary>
+        /// IPv6 local link multicast address.
+        /// </summary>
+        public static readonly IPAddress MulticastIPv6LinkLocal = IPAddress.Parse("ff02::C");
+
+        /// <summary>
+        /// IPv6 site local multicast address.
+        /// </summary>
+        public static readonly IPAddress MulticastIPv6SiteLocal = IPAddress.Parse("ff05::C");
+
+        /// <summary>
+        /// IP4Loopback address host.
+        /// </summary>
+        public static readonly IPNetAddress IP4Loopback = IPNetAddress.Parse("127.0.0.1/32");
+
+        /// <summary>
+        /// IP6Loopback address host.
+        /// </summary>
+        public static readonly IPNetAddress IP6Loopback = IPNetAddress.Parse("::1");
+
+        /// <summary>
+        /// Object's IP address.
+        /// </summary>
+        private IPAddress _address;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPNetAddress"/> class.
+        /// </summary>
+        /// <param name="address">Address to assign.</param>
+        public IPNetAddress(IPAddress address)
+        {
+            _address = address ?? throw new ArgumentNullException(nameof(address));
+            PrefixLength = (byte)(address.AddressFamily == AddressFamily.InterNetwork ? 32 : 128);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPNetAddress"/> class.
+        /// </summary>
+        /// <param name="address">IP Address.</param>
+        /// <param name="prefixLength">Mask as a CIDR.</param>
+        public IPNetAddress(IPAddress address, byte prefixLength)
+        {
+            if (address?.IsIPv4MappedToIPv6 ?? throw new ArgumentNullException(nameof(address)))
+            {
+                _address = address.MapToIPv4();
+            }
+            else
+            {
+                _address = address;
+            }
+
+            PrefixLength = prefixLength;
+        }
+
+        /// <summary>
+        /// Gets or sets the object's IP address.
+        /// </summary>
+        public override IPAddress Address
+        {
+            get
+            {
+                return _address;
+            }
+
+            set
+            {
+                _address = value ?? IPAddress.None;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override byte PrefixLength { get; set; }
+
+        /// <summary>
+        /// Try to parse the address and subnet strings into an IPNetAddress object.
+        /// </summary>
+        /// <param name="addr">IP address to parse. Can be CIDR or X.X.X.X notation.</param>
+        /// <param name="ip">Resultant object.</param>
+        /// <returns>True if the values parsed successfully. False if not, resulting in the IP being null.</returns>
+        public static bool TryParse(string addr, out IPNetAddress ip)
+        {
+            if (!string.IsNullOrEmpty(addr))
+            {
+                addr = addr.Trim();
+
+                // Try to parse it as is.
+                if (IPAddress.TryParse(addr, out IPAddress res))
+                {
+                    ip = new IPNetAddress(res);
+                    return true;
+                }
+
+                // Is it a network?
+                string[] tokens = addr.Split("/");
+
+                if (tokens.Length == 2)
+                {
+                    tokens[0] = tokens[0].TrimEnd();
+                    tokens[1] = tokens[1].TrimStart();
+
+                    if (IPAddress.TryParse(tokens[0], out res))
+                    {
+                        // Is the subnet part a cidr?
+                        if (byte.TryParse(tokens[1], out byte cidr))
+                        {
+                            ip = new IPNetAddress(res, cidr);
+                            return true;
+                        }
+
+                        // Is the subnet in x.y.a.b form?
+                        if (IPAddress.TryParse(tokens[1], out IPAddress mask))
+                        {
+                            ip = new IPNetAddress(res, MaskToCidr(mask));
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            ip = None;
+            return false;
+        }
+
+        /// <summary>
+        /// Parses the string provided, throwing an exception if it is badly formed.
+        /// </summary>
+        /// <param name="addr">String to parse.</param>
+        /// <returns>IPNetAddress object.</returns>
+        public static IPNetAddress Parse(string addr)
+        {
+            if (TryParse(addr, out IPNetAddress o))
+            {
+                return o;
+            }
+
+            throw new ArgumentException("Unable to recognise object :" + addr);
+        }
+
+        /// <inheritdoc/>
+        public override bool Contains(IPAddress address)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (address.IsIPv4MappedToIPv6)
+            {
+                address = address.MapToIPv4();
+            }
+
+            var altAddress = NetworkAddressOf(address, PrefixLength);
+            return NetworkAddress.Address.Equals(altAddress.Address) && NetworkAddress.PrefixLength >= altAddress.PrefixLength;
+        }
+
+        /// <inheritdoc/>
+        public override bool Contains(IPObject address)
+        {
+            if (address is IPHost addressObj && addressObj.HasAddress)
+            {
+                foreach (IPAddress addr in addressObj.GetAddresses())
+                {
+                    if (Contains(addr))
+                    {
+                        return true;
+                    }
+                }
+            }
+            else if (address is IPNetAddress netaddrObj)
+            {
+                // Have the same network address, but different subnets?
+                if (NetworkAddress.Address.Equals(netaddrObj.NetworkAddress.Address))
+                {
+                    return NetworkAddress.PrefixLength <= netaddrObj.PrefixLength;
+                }
+
+                var altAddress = NetworkAddressOf(netaddrObj.Address, PrefixLength);
+                return NetworkAddress.Address.Equals(altAddress.Address);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(IPObject? other)
+        {
+            if (other is IPNetAddress otherObj && !Address.Equals(IPAddress.None) && !otherObj.Address.Equals(IPAddress.None))
+            {
+                return Address.Equals(otherObj.Address) &&
+                    PrefixLength == otherObj.PrefixLength;
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(IPAddress address)
+        {
+            if (address != null && !address.Equals(IPAddress.None) && !Address.Equals(IPAddress.None))
+            {
+                return address.Equals(Address);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            return ToString(false);
+        }
+
+        /// <summary>
+        /// Returns a textual representation of this object.
+        /// </summary>
+        /// <param name="shortVersion">Set to true, if the subnet is to be included as part of the address.</param>
+        /// <returns>String representation of this object.</returns>
+        public string ToString(bool shortVersion)
+        {
+            if (!Address.Equals(IPAddress.None))
+            {
+                if (Address.Equals(IPAddress.Any))
+                {
+                    return "Any IP4 Address";
+                }
+
+                if (Address.Equals(IPAddress.IPv6Any))
+                {
+                    return "Any IP6 Address";
+                }
+
+                if (Address.Equals(IPAddress.Broadcast))
+                {
+                    return "Any Address";
+                }
+
+                if (shortVersion)
+                {
+                    return Address.ToString();
+                }
+
+                return $"{Address}/{PrefixLength}";
+            }
+
+            return string.Empty;
+        }
+
+        /// <inheritdoc/>
+        protected override IPObject CalculateNetworkAddress()
+        {
+            var value = NetworkAddressOf(_address, PrefixLength);
+            return new IPNetAddress(value.Address, value.PrefixLength);
+        }
+    }
+}
diff --git a/MediaBrowser.Common/Net/IPObject.cs b/MediaBrowser.Common/Net/IPObject.cs
new file mode 100644
index 0000000000..a08694c266
--- /dev/null
+++ b/MediaBrowser.Common/Net/IPObject.cs
@@ -0,0 +1,395 @@
+#nullable enable
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace MediaBrowser.Common.Net
+{
+    /// <summary>
+    /// Base network object class.
+    /// </summary>
+    public abstract class IPObject : IEquatable<IPObject>
+    {
+        /// <summary>
+        /// IPv6 Loopback address.
+        /// </summary>
+        protected static readonly byte[] Ipv6Loopback = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+        /// <summary>
+        /// IPv4 Loopback address.
+        /// </summary>
+        protected static readonly byte[] Ipv4Loopback = { 127, 0, 0, 1 };
+
+        /// <summary>
+        /// The network address of this object.
+        /// </summary>
+        private IPObject? _networkAddress;
+
+        /// <summary>
+        /// Gets or sets the user defined functions that need storage in this object.
+        /// </summary>
+        public int Tag { get; set; }
+
+        /// <summary>
+        /// Gets or sets the object's IP address.
+        /// </summary>
+        public abstract IPAddress Address { get; set; }
+
+        /// <summary>
+        /// Gets the object's network address.
+        /// </summary>
+        public IPObject NetworkAddress
+        {
+            get
+            {
+                if (_networkAddress == null)
+                {
+                    _networkAddress = CalculateNetworkAddress();
+                }
+
+                return _networkAddress;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the object's IP address.
+        /// </summary>
+        public abstract byte PrefixLength { get; set; }
+
+        /// <summary>
+        /// Gets the AddressFamily of this object.
+        /// </summary>
+        public AddressFamily AddressFamily
+        {
+            get
+            {
+                // Keep terms separate as Address performs other functions in inherited objects.
+                IPAddress address = Address;
+                return address.Equals(IPAddress.None) ? AddressFamily.Unspecified : address.AddressFamily;
+            }
+        }
+
+        /// <summary>
+        /// Returns the network address of an object.
+        /// </summary>
+        /// <param name="address">IP Address to convert.</param>
+        /// <param name="prefixLength">Subnet prefix.</param>
+        /// <returns>IPAddress.</returns>
+        public static (IPAddress Address, byte PrefixLength) NetworkAddressOf(IPAddress address, byte prefixLength)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (address.IsIPv4MappedToIPv6)
+            {
+                address = address.MapToIPv4();
+            }
+
+            if (IsLoopback(address))
+            {
+                return (Address: address, PrefixLength: prefixLength);
+            }
+
+            byte[] addressBytes = address.GetAddressBytes();
+
+            int div = prefixLength / 8;
+            int mod = prefixLength % 8;
+            if (mod != 0)
+            {
+                mod = 8 - mod;
+                addressBytes[div] = (byte)((int)addressBytes[div] >> mod << mod);
+                div++;
+            }
+
+            for (int octet = div; octet < addressBytes.Length; octet++)
+            {
+                addressBytes[octet] = 0;
+            }
+
+            return (Address: new IPAddress(addressBytes), PrefixLength: prefixLength);
+        }
+
+        /// <summary>
+        /// Tests to see if the ip address is a Loopback address.
+        /// </summary>
+        /// <param name="address">Value to test.</param>
+        /// <returns>True if it is.</returns>
+        public static bool IsLoopback(IPAddress address)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (!address.Equals(IPAddress.None))
+            {
+                if (address.IsIPv4MappedToIPv6)
+                {
+                    address = address.MapToIPv4();
+                }
+
+                return address.Equals(IPAddress.Loopback) || address.Equals(IPAddress.IPv6Loopback);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Tests to see if the ip address is an IP6 address.
+        /// </summary>
+        /// <param name="address">Value to test.</param>
+        /// <returns>True if it is.</returns>
+        public static bool IsIP6(IPAddress address)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (address.IsIPv4MappedToIPv6)
+            {
+                address = address.MapToIPv4();
+            }
+
+            return !address.Equals(IPAddress.None) && (address.AddressFamily == AddressFamily.InterNetworkV6);
+        }
+
+        /// <summary>
+        /// Tests to see if the address in the private address range.
+        /// </summary>
+        /// <param name="address">Object to test.</param>
+        /// <returns>True if it contains a private address.</returns>
+        public static bool IsPrivateAddressRange(IPAddress address)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (!address.Equals(IPAddress.None))
+            {
+                if (address.AddressFamily == AddressFamily.InterNetwork)
+                {
+                    if (address.IsIPv4MappedToIPv6)
+                    {
+                        address = address.MapToIPv4();
+                    }
+
+                    byte[] octet = address.GetAddressBytes();
+
+                    return (octet[0] == 10) ||
+                        (octet[0] == 172 && octet[1] >= 16 && octet[1] <= 31) || // RFC1918
+                        (octet[0] == 192 && octet[1] == 168) || // RFC1918
+                        (octet[0] == 127); // RFC1122
+                }
+                else
+                {
+                    byte[] octet = address.GetAddressBytes();
+                    uint word = (uint)(octet[0] << 8) + octet[1];
+
+                    return (word >= 0xfe80 && word <= 0xfebf) || // fe80::/10 :Local link.
+                           (word >= 0xfc00 && word <= 0xfdff); // fc00::/7 :Unique local address.
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns true if the IPAddress contains an IP6 Local link address.
+        /// </summary>
+        /// <param name="address">IPAddress object to check.</param>
+        /// <returns>True if it is a local link address.</returns>
+        /// <remarks>See https://stackoverflow.com/questions/6459928/explain-the-instance-properties-of-system-net-ipaddress
+        /// it appears that the IPAddress.IsIPv6LinkLocal is out of date.
+        /// </remarks>
+        public static bool IsIPv6LinkLocal(IPAddress address)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
+
+            if (address.IsIPv4MappedToIPv6)
+            {
+                address = address.MapToIPv4();
+            }
+
+            if (address.AddressFamily != AddressFamily.InterNetworkV6)
+            {
+                return false;
+            }
+
+            byte[] octet = address.GetAddressBytes();
+            uint word = (uint)(octet[0] << 8) + octet[1];
+
+            return word >= 0xfe80 && word <= 0xfebf; // fe80::/10 :Local link.
+        }
+
+        /// <summary>
+        /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only.
+        /// </summary>
+        /// <param name="cidr">Subnet mask in CIDR notation.</param>
+        /// <param name="family">IPv4 or IPv6 family.</param>
+        /// <returns>String value of the subnet mask in dotted decimal notation.</returns>
+        public static IPAddress CidrToMask(byte cidr, AddressFamily family)
+        {
+            uint addr = 0xFFFFFFFF << (family == AddressFamily.InterNetwork ? 32 : 128 - cidr);
+            addr =
+                ((addr & 0xff000000) >> 24) |
+                ((addr & 0x00ff0000) >> 8) |
+                ((addr & 0x0000ff00) << 8) |
+                ((addr & 0x000000ff) << 24);
+            return new IPAddress(addr);
+        }
+
+        /// <summary>
+        /// Convert a mask to a CIDR. IPv4 only.
+        /// https://stackoverflow.com/questions/36954345/get-cidr-from-netmask.
+        /// </summary>
+        /// <param name="mask">Subnet mask.</param>
+        /// <returns>Byte CIDR representing the mask.</returns>
+        public static byte MaskToCidr(IPAddress mask)
+        {
+            if (mask == null)
+            {
+                throw new ArgumentNullException(nameof(mask));
+            }
+
+            byte cidrnet = 0;
+            if (!mask.Equals(IPAddress.Any))
+            {
+                byte[] bytes = mask.GetAddressBytes();
+
+                var zeroed = false;
+                for (var i = 0; i < bytes.Length; i++)
+                {
+                    for (int v = bytes[i]; (v & 0xFF) != 0; v <<= 1)
+                    {
+                        if (zeroed)
+                        {
+                            // Invalid netmask.
+                            return (byte)~cidrnet;
+                        }
+
+                        if ((v & 0x80) == 0)
+                        {
+                            zeroed = true;
+                        }
+                        else
+                        {
+                            cidrnet++;
+                        }
+                    }
+                }
+            }
+
+            return cidrnet;
+        }
+
+        /// <summary>
+        /// Tests to see if this object is a Loopback address.
+        /// </summary>
+        /// <returns>True if it is.</returns>
+        public virtual bool IsLoopback()
+        {
+            return IsLoopback(Address);
+        }
+
+        /// <summary>
+        /// Removes all addresses of a specific type from this object.
+        /// </summary>
+        /// <param name="family">Type of address to remove.</param>
+        public virtual void Remove(AddressFamily family)
+        {
+            // This method only peforms a function in the IPHost implementation of IPObject.
+        }
+
+        /// <summary>
+        /// Tests to see if this object is an IPv6 address.
+        /// </summary>
+        /// <returns>True if it is.</returns>
+        public virtual bool IsIP6()
+        {
+            return IsIP6(Address);
+        }
+
+        /// <summary>
+        /// Returns true if this IP address is in the RFC private address range.
+        /// </summary>
+        /// <returns>True this object has a private address.</returns>
+        public virtual bool IsPrivateAddressRange()
+        {
+            return IsPrivateAddressRange(Address);
+        }
+
+        /// <summary>
+        /// Compares this to the object passed as a parameter.
+        /// </summary>
+        /// <param name="ip">Object to compare to.</param>
+        /// <returns>Equality result.</returns>
+        public virtual bool Equals(IPAddress ip)
+        {
+            if (ip != null)
+            {
+                if (ip.IsIPv4MappedToIPv6)
+                {
+                    ip = ip.MapToIPv4();
+                }
+
+                return !Address.Equals(IPAddress.None) && Address.Equals(ip);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Compares this to the object passed as a parameter.
+        /// </summary>
+        /// <param name="other">Object to compare to.</param>
+        /// <returns>Equality result.</returns>
+        public virtual bool Equals(IPObject? other)
+        {
+            if (other != null && other is IPObject otherObj)
+            {
+                return !Address.Equals(IPAddress.None) && Address.Equals(otherObj.Address);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Compares the address in this object and the address in the object passed as a parameter.
+        /// </summary>
+        /// <param name="address">Object's IP address to compare to.</param>
+        /// <returns>Comparison result.</returns>
+        public abstract bool Contains(IPObject address);
+
+        /// <summary>
+        /// Compares the address in this object and the address in the object passed as a parameter.
+        /// </summary>
+        /// <param name="address">Object's IP address to compare to.</param>
+        /// <returns>Comparison result.</returns>
+        public abstract bool Contains(IPAddress address);
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return Address.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as IPObject);
+        }
+
+        /// <summary>
+        /// Calculates the network address of this object.
+        /// </summary>
+        /// <returns>Returns the network address of this object.</returns>
+        protected abstract IPObject CalculateNetworkAddress();
+    }
+}
diff --git a/MediaBrowser.Common/Net/NetworkExtensions.cs b/MediaBrowser.Common/Net/NetworkExtensions.cs
new file mode 100644
index 0000000000..6e9cb46dc1
--- /dev/null
+++ b/MediaBrowser.Common/Net/NetworkExtensions.cs
@@ -0,0 +1,254 @@
+#pragma warning disable CA1062 // Validate arguments of public methods
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Net;
+using System.Runtime.CompilerServices;
+using NetCollection = System.Collections.ObjectModel.Collection<MediaBrowser.Common.Net.IPObject>;
+
+namespace MediaBrowser.Common.Net
+{
+    /// <summary>
+    /// Defines the <see cref="NetworkExtensions" />.
+    /// </summary>
+    public static class NetworkExtensions
+    {
+        /// <summary>
+        /// Add an address to the collection.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="ip">Item to add.</param>
+        public static void AddItem(this NetCollection source, IPAddress ip)
+        {
+            if (!source.ContainsAddress(ip))
+            {
+                source.Add(new IPNetAddress(ip, 32));
+            }
+        }
+
+        /// <summary>
+        /// Add multiple items to the collection.
+        /// </summary>
+        /// <param name="destination">The <see cref="NetCollection"/>.</param>
+        /// <param name="source">Item to add.</param>
+        /// <returns>Return the collection.</returns>
+        public static NetCollection AddRange(this NetCollection destination, IEnumerable<IPObject> source)
+        {
+            foreach (var item in source)
+            {
+                destination.Add(item);
+            }
+
+            return destination;
+        }
+
+        /// <summary>
+        /// Adds a network to the collection.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="item">Item to add.</param>
+        public static void AddItem(this NetCollection source, IPObject item)
+        {
+            if (!source.ContainsAddress(item))
+            {
+                source.Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Converts this object to a string.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <returns>Returns a string representation of this object.</returns>
+        public static string Readable(this NetCollection source)
+        {
+            string output = "[";
+            if (source.Count > 0)
+            {
+                foreach (var i in source)
+                {
+                    output += $"{i},";
+                }
+
+                output = output[0..^1];
+            }
+
+            return $"{output}]";
+        }
+
+        /// <summary>
+        /// Returns true if the collection contains an item with the ip address,
+        /// or the ip address falls within any of the collection's network ranges.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="item">The item to look for.</param>
+        /// <returns>True if the collection contains the item.</returns>
+        public static bool ContainsAddress(this NetCollection source, IPAddress item)
+        {
+            if (source.Count == 0)
+            {
+                return false;
+            }
+
+            if (item == null)
+            {
+                throw new ArgumentNullException(nameof(item));
+            }
+
+            if (item.IsIPv4MappedToIPv6)
+            {
+                item = item.MapToIPv4();
+            }
+
+            foreach (var i in source)
+            {
+                if (i.Contains(item))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns true if the collection contains an item with the ip address,
+        /// or the ip address falls within any of the collection's network ranges.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="item">The item to look for.</param>
+        /// <returns>True if the collection contains the item.</returns>
+        public static bool ContainsAddress(this NetCollection source, IPObject item)
+        {
+            if (source.Count == 0)
+            {
+                return false;
+            }
+
+            if (item == null)
+            {
+                throw new ArgumentNullException(nameof(item));
+            }
+
+            foreach (var i in source)
+            {
+                if (i.Contains(item))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a collection containing the subnets of this collection given.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <returns>NetCollection object containing the subnets.</returns>
+        public static NetCollection AsNetworks(this NetCollection source)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+
+            NetCollection res = new NetCollection();
+
+            foreach (IPObject i in source)
+            {
+                if (i is IPNetAddress nw)
+                {
+                    // Add the subnet calculated from the interface address/mask.
+                    var na = nw.NetworkAddress;
+                    na.Tag = i.Tag;
+                    res.Add(na);
+                }
+                else
+                {
+                    // Flatten out IPHost and add all its ip addresses.
+                    foreach (var addr in ((IPHost)i).GetAddresses())
+                    {
+                        IPNetAddress host = new IPNetAddress(addr)
+                        {
+                            Tag = i.Tag
+                        };
+
+                        res.Add(host);
+                    }
+                }
+            }
+
+            return res;
+        }
+
+        /// <summary>
+        /// Excludes all the items from this list that are found in excludeList.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="excludeList">Items to exclude.</param>
+        /// <returns>A new collection, with the items excluded.</returns>
+        public static NetCollection Exclude(this NetCollection source, NetCollection excludeList)
+        {
+            if (source.Count == 0 || excludeList == null)
+            {
+                return new NetCollection(source);
+            }
+
+            NetCollection results = new NetCollection();
+
+            bool found;
+            foreach (var outer in source)
+            {
+                found = false;
+
+                foreach (var inner in excludeList)
+                {
+                    if (outer.Equals(inner))
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+
+                if (!found)
+                {
+                    results.Add(outer);
+                }
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// Returns all items that co-exist in this object and target.
+        /// </summary>
+        /// <param name="source">The <see cref="NetCollection"/>.</param>
+        /// <param name="target">Collection to compare with.</param>
+        /// <returns>A collection containing all the matches.</returns>
+        public static NetCollection Union(this NetCollection source, NetCollection target)
+        {
+            if (source.Count == 0)
+            {
+                return new NetCollection();
+            }
+
+            if (target == null)
+            {
+                throw new ArgumentNullException(nameof(target));
+            }
+
+            NetCollection nc = new NetCollection();
+
+            foreach (IPObject i in source)
+            {
+                if (target.ContainsAddress(i))
+                {
+                    nc.Add(i);
+                }
+            }
+
+            return nc;
+        }
+    }
+}