Migrate NetworkManager and Tests to native .NET IP objects

1 files changed, 135 insertions, 174 deletions

diff --git a/MediaBrowser.Common/Net/NetworkExtensions.cs b/MediaBrowser.Common/Net/NetworkExtensions.cs
index 264bfacb4..55ec322f4 100644
--- a/MediaBrowser.Common/Net/NetworkExtensions.cs
+++ b/MediaBrowser.Common/Net/NetworkExtensions.cs
@@ -1,6 +1,9 @@
 using System;
-using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Net;
+using System.Net.Sockets;
+using System.Text.RegularExpressions;
 
 namespace MediaBrowser.Common.Net
 {
@@ -10,251 +13,209 @@ namespace MediaBrowser.Common.Net
     public static class NetworkExtensions
     {
         /// <summary>
-        /// Add an address to the collection.
+        /// Returns true if the IPAddress contains an IP6 Local link address.
         /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="ip">Item to add.</param>
-        public static void AddItem(this Collection<IPObject> source, IPAddress ip)
+        /// <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 (!source.ContainsAddress(ip))
+            if (address == null)
             {
-                source.Add(new IPNetAddress(ip, 32));
+                throw new ArgumentNullException(nameof(address));
             }
-        }
 
-        /// <summary>
-        /// Adds a network to the collection.
-        /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="item">Item to add.</param>
-        /// <param name="itemsAreNetworks">If <c>true</c> the values are treated as subnets.
-        /// If <b>false</b> items are addresses.</param>
-        public static void AddItem(this Collection<IPObject> source, IPObject item, bool itemsAreNetworks = true)
-        {
-            if (!source.ContainsAddress(item) || !itemsAreNetworks)
+            if (address.IsIPv4MappedToIPv6)
             {
-                source.Add(item);
+                address = address.MapToIPv4();
             }
-        }
 
-        /// <summary>
-        /// Converts this object to a string.
-        /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <returns>Returns a string representation of this object.</returns>
-        public static string AsString(this Collection<IPObject> source)
-        {
-            return $"[{string.Join(',', source)}]";
-        }
-
-        /// <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="Collection{IPObject}"/>.</param>
-        /// <param name="item">The item to look for.</param>
-        /// <returns>True if the collection contains the item.</returns>
-        public static bool ContainsAddress(this Collection<IPObject> source, IPAddress item)
-        {
-            if (source.Count == 0)
+            if (address.AddressFamily != AddressFamily.InterNetworkV6)
             {
                 return false;
             }
 
-            if (item == null)
-            {
-                throw new ArgumentNullException(nameof(item));
-            }
-
-            if (item.IsIPv4MappedToIPv6)
-            {
-                item = item.MapToIPv4();
-            }
+            // GetAddressBytes
+            Span<byte> octet = stackalloc byte[16];
+            address.TryWriteBytes(octet, out _);
+            uint word = (uint)(octet[0] << 8) + octet[1];
 
-            foreach (var i in source)
-            {
-                if (i.Contains(item))
-                {
-                    return true;
-                }
-            }
+            return word >= 0xfe80 && word <= 0xfebf; // fe80::/10 :Local link.
+        }
 
-            return false;
+        /// <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>
-        /// 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.
+        /// Convert a subnet mask to a CIDR. IPv4 only.
+        /// https://stackoverflow.com/questions/36954345/get-cidr-from-netmask.
         /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="item">The item to look for.</param>
-        /// <returns>True if the collection contains the item.</returns>
-        public static bool ContainsAddress(this Collection<IPObject> source, IPObject item)
+        /// <param name="mask">Subnet mask.</param>
+        /// <returns>Byte CIDR representing the mask.</returns>
+        public static byte MaskToCidr(IPAddress mask)
         {
-            if (source.Count == 0)
+            if (mask == null)
             {
-                return false;
+                throw new ArgumentNullException(nameof(mask));
             }
 
-            if (item == null)
+            byte cidrnet = 0;
+            if (!mask.Equals(IPAddress.Any))
             {
-                throw new ArgumentNullException(nameof(item));
-            }
+                // GetAddressBytes
+                Span<byte> bytes = stackalloc byte[mask.AddressFamily == AddressFamily.InterNetwork ? 4 : 16];
+                mask.TryWriteBytes(bytes, out _);
 
-            foreach (var i in source)
-            {
-                if (i.Contains(item))
+                var zeroed = false;
+                for (var i = 0; i < bytes.Length; i++)
                 {
-                    return true;
+                    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 false;
+            return cidrnet;
         }
 
         /// <summary>
-        /// Compares two Collection{IPObject} objects. The order is ignored.
+        /// Converts an IPAddress into a string.
+        /// Ipv6 addresses are returned in [ ], with their scope removed.
         /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="dest">Item to compare to.</param>
-        /// <returns>True if both are equal.</returns>
-        public static bool Compare(this Collection<IPObject> source, Collection<IPObject> dest)
+        /// <param name="address">Address to convert.</param>
+        /// <returns>URI safe conversion of the address.</returns>
+        public static string FormatIpString(IPAddress? address)
         {
-            if (dest == null || source.Count != dest.Count)
+            if (address == null)
             {
-                return false;
+                return string.Empty;
             }
 
-            foreach (var sourceItem in source)
+            var str = address.ToString();
+            if (address.AddressFamily == AddressFamily.InterNetworkV6)
             {
-                bool found = false;
-                foreach (var destItem in dest)
+                int i = str.IndexOf('%', StringComparison.Ordinal);
+                if (i != -1)
                 {
-                    if (sourceItem.Equals(destItem))
-                    {
-                        found = true;
-                        break;
-                    }
+                    str = str.Substring(0, i);
                 }
 
-                if (!found)
-                {
-                    return false;
-                }
+                return $"[{str}]";
             }
 
-            return true;
+            return str;
         }
 
         /// <summary>
-        /// Returns a collection containing the subnets of this collection given.
+        /// Attempts to parse a host string.
         /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <returns>Collection{IPObject} object containing the subnets.</returns>
-        public static Collection<IPObject> AsNetworks(this Collection<IPObject> source)
+        /// <param name="host">Host name to parse.</param>
+        /// <param name="addresses">Object representing the string, if it has successfully been parsed.</param>
+        /// <param name="isIpv4Enabled"><c>true</c> if IPv4 is enabled.</param>
+        /// <param name="isIpv6Enabled"><c>true</c> if IPv6 is enabled.</param>
+        /// <returns><c>true</c> if the parsing is successful, <c>false</c> if not.</returns>
+        public static bool TryParseHost(string host, [NotNullWhen(true)] out IPAddress[] addresses, bool isIpv4Enabled = true, bool isIpv6Enabled = false)
         {
-            if (source == null)
+            if (string.IsNullOrWhiteSpace(host))
             {
-                throw new ArgumentNullException(nameof(source));
+                addresses = Array.Empty<IPAddress>();
+                return false;
             }
 
-            Collection<IPObject> res = new Collection<IPObject>();
+            host = host.Trim();
 
-            foreach (IPObject i in source)
+            // See if it's an IPv6 with port address e.g. [::1] or [::1]:120.
+            if (host[0] == '[')
             {
-                if (i is IPNetAddress nw)
-                {
-                    // Add the subnet calculated from the interface address/mask.
-                    var na = nw.NetworkAddress;
-                    na.Tag = i.Tag;
-                    res.AddItem(na);
-                }
-                else if (i is IPHost ipHost)
+                int i = host.IndexOf(']', StringComparison.Ordinal);
+                if (i != -1)
                 {
-                    // Flatten out IPHost and add all its ip addresses.
-                    foreach (var addr in ipHost.GetAddresses())
-                    {
-                        IPNetAddress host = new IPNetAddress(addr)
-                        {
-                            Tag = i.Tag
-                        };
-
-                        res.AddItem(host);
-                    }
+                    return TryParseHost(host.Remove(i)[1..], out addresses);
                 }
-            }
-
-            return res;
-        }
 
-        /// <summary>
-        /// Excludes all the items from this list that are found in excludeList.
-        /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="excludeList">Items to exclude.</param>
-        /// <param name="isNetwork">Collection is a network collection.</param>
-        /// <returns>A new collection, with the items excluded.</returns>
-        public static Collection<IPObject> Exclude(this Collection<IPObject> source, Collection<IPObject> excludeList, bool isNetwork)
-        {
-            if (source.Count == 0 || excludeList == null)
-            {
-                return new Collection<IPObject>(source);
+                addresses = Array.Empty<IPAddress>();
+                return false;
             }
 
-            Collection<IPObject> results = new Collection<IPObject>();
+            var hosts = host.Split(':');
 
-            bool found;
-            foreach (var outer in source)
+            if (hosts.Length <= 2)
             {
-                found = false;
+                // 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
+                string pattern = @"(?im)^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){0,127}(?![0-9]*$)[a-z0-9-]+\.?)(:(\d){1,5}){0,1}$";
 
-                foreach (var inner in excludeList)
+                // Is hostname or hostname:port
+                if (Regex.IsMatch(hosts[0], pattern))
                 {
-                    if (outer.Equals(inner))
+                    try
+                    {
+                        addresses = Dns.GetHostAddresses(hosts[0]);
+                        return true;
+                    }
+                    catch (SocketException)
                     {
-                        found = true;
-                        break;
+                        // Log and then ignore socket errors, as the result value will just be an empty array.
+                        Console.WriteLine("GetHostAddresses failed.");
                     }
                 }
 
-                if (!found)
-                {
-                    results.AddItem(outer, isNetwork);
-                }
-            }
+                // Is an IP4 or IP4:port
+                host = hosts[0].Split('/')[0];
 
-            return results;
-        }
+                if (IPAddress.TryParse(host, out var address))
+                {
+                    if (((address.AddressFamily == AddressFamily.InterNetwork) && (!isIpv4Enabled && isIpv6Enabled)) ||
+                        ((address.AddressFamily == AddressFamily.InterNetworkV6) && (isIpv4Enabled && !isIpv6Enabled)))
+                    {
+                        addresses = Array.Empty<IPAddress>();
+                        return false;
+                    }
 
-        /// <summary>
-        /// Returns all items that co-exist in this object and target.
-        /// </summary>
-        /// <param name="source">The <see cref="Collection{IPObject}"/>.</param>
-        /// <param name="target">Collection to compare with.</param>
-        /// <returns>A collection containing all the matches.</returns>
-        public static Collection<IPObject> ThatAreContainedInNetworks(this Collection<IPObject> source, Collection<IPObject> target)
-        {
-            if (source.Count == 0)
-            {
-                return new Collection<IPObject>();
-            }
+                    addresses = new[] { address };
 
-            if (target == null)
-            {
-                throw new ArgumentNullException(nameof(target));
+                    // Host name is an ip4 address, so fake resolve.
+                    return true;
+                }
             }
-
-            Collection<IPObject> nc = new Collection<IPObject>();
-
-            foreach (IPObject i in source)
+            else if (hosts.Length <= 9 && IPAddress.TryParse(host.Split('/')[0], out var address)) // 8 octets + port
             {
-                if (target.ContainsAddress(i))
-                {
-                    nc.AddItem(i);
-                }
+                addresses = new[] { address };
+                return true;
             }
 
-            return nc;
+            addresses = Array.Empty<IPAddress>();
+            return false;
         }
     }
 }