Migrate NetworkManager and Tests to native .NET IP objects

18 files changed, 957 insertions, 2504 deletions

diff --git a/Emby.Dlna/Main/DlnaEntryPoint.cs b/Emby.Dlna/Main/DlnaEntryPoint.cs
index 15021c19d..01a9def0b 100644
--- a/Emby.Dlna/Main/DlnaEntryPoint.cs
+++ b/Emby.Dlna/Main/DlnaEntryPoint.cs
@@ -3,15 +3,16 @@
 #pragma warning disable CS1591
 
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
 using System.Net.Sockets;
 using System.Threading.Tasks;
 using Emby.Dlna.PlayTo;
 using Emby.Dlna.Ssdp;
 using Jellyfin.Networking.Configuration;
-using Jellyfin.Networking.Manager;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Common.Net;
@@ -285,9 +286,11 @@ namespace Emby.Dlna.Main
             var udn = CreateUuid(_appHost.SystemId);
             var descriptorUri = "/dlna/" + udn + "/description.xml";
 
-            var bindAddresses = NetworkManager.CreateCollection(
-                _networkManager.GetInternalBindAddresses()
-                .Where(i => i.AddressFamily == AddressFamily.InterNetwork || (i.AddressFamily == AddressFamily.InterNetworkV6 && i.Address.ScopeId != 0)));
+            var bindAddresses = _networkManager
+                .GetInternalBindAddresses()
+                .Where(i => i.Address.AddressFamily == AddressFamily.InterNetwork
+                    || (i.AddressFamily == AddressFamily.InterNetworkV6 && i.Address.ScopeId != 0))
+                .ToList();
 
             if (bindAddresses.Count == 0)
             {
@@ -295,7 +298,7 @@ namespace Emby.Dlna.Main
                 bindAddresses = _networkManager.GetLoopbacks();
             }
 
-            foreach (IPNetAddress address in bindAddresses)
+            foreach (var address in bindAddresses)
             {
                 if (address.AddressFamily == AddressFamily.InterNetworkV6)
                 {
@@ -304,7 +307,7 @@ namespace Emby.Dlna.Main
                 }
 
                 // Limit to LAN addresses only
-                if (!_networkManager.IsInLocalNetwork(address))
+                if (!_networkManager.IsInLocalNetwork(address.Address))
                 {
                     continue;
                 }
@@ -313,14 +316,14 @@ namespace Emby.Dlna.Main
 
                 _logger.LogInformation("Registering publisher for {ResourceName} on {DeviceAddress}", fullService, address);
 
-                var uri = new UriBuilder(_appHost.GetApiUrlForLocalAccess(address, false) + descriptorUri);
+                var uri = new UriBuilder(_appHost.GetApiUrlForLocalAccess(address.Address, false) + descriptorUri);
 
                 var device = new SsdpRootDevice
                 {
                     CacheLifetime = TimeSpan.FromSeconds(1800), // How long SSDP clients can cache this info.
                     Location = uri.Uri, // Must point to the URL that serves your devices UPnP description document.
                     Address = address.Address,
-                    PrefixLength = address.PrefixLength,
+                    PrefixLength = NetworkExtensions.MaskToCidr(address.Subnet.Prefix),
                     FriendlyName = "Jellyfin",
                     Manufacturer = "Jellyfin",
                     ModelName = "Jellyfin Server",
diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index 32289625f..a0ad4a9ab 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -1114,10 +1114,10 @@ namespace Emby.Server.Implementations
         }
 
         /// <inheritdoc/>
-        public string GetApiUrlForLocalAccess(IPObject hostname = null, bool allowHttps = true)
+        public string GetApiUrlForLocalAccess(IPAddress ipAddress = null, bool allowHttps = true)
         {
             // With an empty source, the port will be null
-            var smart = NetManager.GetBindInterface(hostname ?? IPHost.None, out _);
+            var smart = NetManager.GetBindInterface(ipAddress, out _);
             var scheme = !allowHttps ? Uri.UriSchemeHttp : null;
             int? port = !allowHttps ? HttpPort : null;
             return GetLocalApiUrl(smart, scheme, port);
diff --git a/Jellyfin.Networking/Configuration/NetworkConfiguration.cs b/Jellyfin.Networking/Configuration/NetworkConfiguration.cs
index 61db223d9..0ac55c986 100644
--- a/Jellyfin.Networking/Configuration/NetworkConfiguration.cs
+++ b/Jellyfin.Networking/Configuration/NetworkConfiguration.cs
@@ -113,12 +113,12 @@ namespace Jellyfin.Networking.Configuration
         public string UDPPortRange { get; set; } = string.Empty;
 
         /// <summary>
-        /// Gets or sets a value indicating whether gets or sets IPV6 capability.
+        /// Gets or sets a value indicating whether IPv6 is enabled or not.
         /// </summary>
         public bool EnableIPV6 { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether gets or sets IPV4 capability.
+        /// Gets or sets a value indicating whether IPv6 is enabled or not.
         /// </summary>
         public bool EnableIPV4 { get; set; } = true;
 
@@ -166,12 +166,6 @@ namespace Jellyfin.Networking.Configuration
         public bool EnableMultiSocketBinding { get; } = true;
 
         /// <summary>
-        /// Gets or sets a value indicating whether all IPv6 interfaces should be treated as on the internal network.
-        /// Depending on the address range implemented ULA ranges might not be used.
-        /// </summary>
-        public bool TrustAllIP6Interfaces { get; set; }
-
-        /// <summary>
         /// Gets or sets the ports that HDHomerun uses.
         /// </summary>
         public string HDHomerunPortRange { get; set; } = string.Empty;
diff --git a/Jellyfin.Networking/Manager/NetworkManager.cs b/Jellyfin.Networking/Manager/NetworkManager.cs
index 4b7b87814..f51fd85dd 100644
--- a/Jellyfin.Networking/Manager/NetworkManager.cs
+++ b/Jellyfin.Networking/Manager/NetworkManager.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Net;
@@ -12,30 +11,25 @@ using Jellyfin.Networking.Configuration;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Net;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.Extensions.Logging;
 
 namespace Jellyfin.Networking.Manager
 {
     /// <summary>
     /// Class to take care of network interface management.
-    /// Note: The normal collection methods and properties will not work with Collection{IPObject}. <see cref="MediaBrowser.Common.Net.NetworkExtensions"/>.
     /// </summary>
     public class NetworkManager : INetworkManager, IDisposable
     {
         /// <summary>
-        /// Contains the description of the interface along with its index.
-        /// </summary>
-        private readonly Dictionary<string, int> _interfaceNames;
-
-        /// <summary>
         /// Threading lock for network properties.
         /// </summary>
-        private readonly object _intLock = new object();
+        private readonly object _initLock;
 
         /// <summary>
-        /// List of all interface addresses and masks.
+        /// Dictionary containing interface addresses and their subnets.
         /// </summary>
-        private readonly Collection<IPObject> _interfaceAddresses;
+        private readonly List<IPData> _interfaces;
 
         /// <summary>
         /// List of all interface MAC addresses.
@@ -49,9 +43,11 @@ namespace Jellyfin.Networking.Manager
         private readonly object _eventFireLock;
 
         /// <summary>
-        /// Holds the bind address overrides.
+        /// Holds the published server URLs and the IPs to use them on.
         /// </summary>
-        private readonly Dictionary<IPNetAddress, string> _publishedServerUrls;
+        private readonly Dictionary<IPData, string> _publishedServerUrls;
+
+        private Collection<IPNetwork> _remoteAddressFilter;
 
         /// <summary>
         /// Used to stop "event-racing conditions".
@@ -59,35 +55,25 @@ namespace Jellyfin.Networking.Manager
         private bool _eventfire;
 
         /// <summary>
-        /// Unfiltered user defined LAN subnets. (<see cref="NetworkConfiguration.LocalNetworkSubnets"/>)
+        /// Unfiltered user defined LAN subnets (<see cref="NetworkConfiguration.LocalNetworkSubnets"/>)
         /// or internal interface network subnets if undefined by user.
         /// </summary>
-        private Collection<IPObject> _lanSubnets;
+        private Collection<IPNetwork> _lanSubnets;
 
         /// <summary>
         /// User defined list of subnets to excluded from the LAN.
         /// </summary>
-        private Collection<IPObject> _excludedSubnets;
+        private Collection<IPNetwork> _excludedSubnets;
 
         /// <summary>
-        /// List of interface addresses to bind the WS.
+        /// List of interfaces to bind to.
         /// </summary>
-        private Collection<IPObject> _bindAddresses;
+        private List<IPAddress> _bindAddresses;
 
         /// <summary>
         /// List of interface addresses to exclude from bind.
         /// </summary>
-        private Collection<IPObject> _bindExclusions;
-
-        /// <summary>
-        /// Caches list of all internal filtered interface addresses and masks.
-        /// </summary>
-        private Collection<IPObject> _internalInterfaces;
-
-        /// <summary>
-        /// Flag set when no custom LAN has been defined in the configuration.
-        /// </summary>
-        private bool _usingPrivateAddresses;
+        private List<IPAddress> _bindExclusions;
 
         /// <summary>
         /// True if this object is disposed.
@@ -104,12 +90,12 @@ namespace Jellyfin.Networking.Manager
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _configurationManager = configurationManager ?? throw new ArgumentNullException(nameof(configurationManager));
-
-            _interfaceAddresses = new Collection<IPObject>();
+            _initLock = new();
+            _interfaces = new List<IPData>();
             _macAddresses = new List<PhysicalAddress>();
-            _interfaceNames = new Dictionary<string, int>();
-            _publishedServerUrls = new Dictionary<IPNetAddress, string>();
+            _publishedServerUrls = new Dictionary<IPData, string>();
             _eventFireLock = new object();
+            _remoteAddressFilter = new Collection<IPNetwork>();
 
             UpdateSettings(_configurationManager.GetNetworkConfiguration());
 
@@ -131,46 +117,24 @@ namespace Jellyfin.Networking.Manager
         public static string MockNetworkSettings { get; set; } = string.Empty;
 
         /// <summary>
-        /// Gets or sets a value indicating whether IP6 is enabled.
+        /// Gets a value indicating whether IP4 is enabled.
         /// </summary>
-        public bool IsIP6Enabled { get; set; }
+        public bool IsIpv4Enabled => _configurationManager.GetNetworkConfiguration().EnableIPV4;
 
         /// <summary>
-        /// Gets or sets a value indicating whether IP4 is enabled.
+        /// Gets a value indicating whether IP6 is enabled.
         /// </summary>
-        public bool IsIP4Enabled { get; set; }
-
-        /// <inheritdoc/>
-        public Collection<IPObject> RemoteAddressFilter { get; private set; }
+        public bool IsIpv6Enabled => _configurationManager.GetNetworkConfiguration().EnableIPV6;
 
         /// <summary>
         /// Gets a value indicating whether is all IPv6 interfaces are trusted as internal.
         /// </summary>
-        public bool TrustAllIP6Interfaces { get; internal set; }
+        public bool TrustAllIpv6Interfaces { get; private set; }
 
         /// <summary>
         /// Gets the Published server override list.
         /// </summary>
-        public Dictionary<IPNetAddress, string> PublishedServerUrls => _publishedServerUrls;
-
-        /// <summary>
-        /// Creates a new network collection.
-        /// </summary>
-        /// <param name="source">Items to assign the collection, or null.</param>
-        /// <returns>The collection created.</returns>
-        public static Collection<IPObject> CreateCollection(IEnumerable<IPObject>? source = null)
-        {
-            var result = new Collection<IPObject>();
-            if (source != null)
-            {
-                foreach (var item in source)
-                {
-                    result.AddItem(item, false);
-                }
-            }
-
-            return result;
-        }
+        public Dictionary<IPData, string> PublishedServerUrls => _publishedServerUrls;
 
         /// <inheritdoc/>
         public void Dispose()
@@ -179,418 +143,363 @@ namespace Jellyfin.Networking.Manager
             GC.SuppressFinalize(this);
         }
 
-        /// <inheritdoc/>
-        public IReadOnlyCollection<PhysicalAddress> GetMacAddresses()
+        /// <summary>
+        /// Handler for network change events.
+        /// </summary>
+        /// <param name="sender">Sender.</param>
+        /// <param name="e">A <see cref="NetworkAvailabilityEventArgs"/> containing network availability information.</param>
+        private void OnNetworkAvailabilityChanged(object? sender, NetworkAvailabilityEventArgs e)
         {
-            // Populated in construction - so always has values.
-            return _macAddresses;
+            _logger.LogDebug("Network availability changed.");
+            OnNetworkChanged();
         }
 
-        /// <inheritdoc/>
-        public bool IsGatewayInterface(IPObject? addressObj)
+        /// <summary>
+        /// Handler for network change events.
+        /// </summary>
+        /// <param name="sender">Sender.</param>
+        /// <param name="e">An <see cref="EventArgs"/>.</param>
+        private void OnNetworkAddressChanged(object? sender, EventArgs e)
         {
-            var address = addressObj?.Address ?? IPAddress.None;
-            return _internalInterfaces.Any(i => i.Address.Equals(address) && i.Tag < 0);
+            _logger.LogDebug("Network address change detected.");
+            OnNetworkChanged();
         }
 
-        /// <inheritdoc/>
-        public bool IsGatewayInterface(IPAddress? addressObj)
+        /// <summary>
+        /// Triggers our event, and re-loads interface information.
+        /// </summary>
+        private void OnNetworkChanged()
         {
-            return _internalInterfaces.Any(i => i.Address.Equals(addressObj ?? IPAddress.None) && i.Tag < 0);
+            lock (_eventFireLock)
+            {
+                if (!_eventfire)
+                {
+                    _logger.LogDebug("Network Address Change Event.");
+                    // As network events tend to fire one after the other only fire once every second.
+                    _eventfire = true;
+                    OnNetworkChangeAsync().GetAwaiter().GetResult();
+                }
+            }
         }
 
-        /// <inheritdoc/>
-        public Collection<IPObject> GetLoopbacks()
+        /// <summary>
+        /// Async task that waits for 2 seconds before re-initialising the settings, as typically these events fire multiple times in succession.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        private async Task OnNetworkChangeAsync()
         {
-            Collection<IPObject> nc = new Collection<IPObject>();
-            if (IsIP4Enabled)
+            try
             {
-                nc.AddItem(IPAddress.Loopback);
-            }
+                await Task.Delay(2000).ConfigureAwait(false);
+                InitialiseInterfaces();
+                // Recalculate LAN caches.
+                InitialiseLan(_configurationManager.GetNetworkConfiguration());
 
-            if (IsIP6Enabled)
+                NetworkChanged?.Invoke(this, EventArgs.Empty);
+            }
+            finally
             {
-                nc.AddItem(IPAddress.IPv6Loopback);
+                _eventfire = false;
             }
-
-            return nc;
-        }
-
-        /// <inheritdoc/>
-        public bool IsExcluded(IPAddress ip)
-        {
-            return _excludedSubnets.ContainsAddress(ip);
-        }
-
-        /// <inheritdoc/>
-        public bool IsExcluded(EndPoint ip)
-        {
-            return ip != null && IsExcluded(((IPEndPoint)ip).Address);
         }
 
-        /// <inheritdoc/>
-        public Collection<IPObject> CreateIPCollection(string[] values, bool negated = false)
+        /// <summary>
+        /// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
+        /// Generate a list of all active mac addresses that aren't loopback addresses.
+        /// </summary>
+        private void InitialiseInterfaces()
         {
-            Collection<IPObject> col = new Collection<IPObject>();
-            if (values == null)
+            lock (_initLock)
             {
-                return col;
-            }
+                _logger.LogDebug("Refreshing interfaces.");
 
-            for (int a = 0; a < values.Length; a++)
-            {
-                string v = values[a].Trim();
+                _interfaces.Clear();
+                _macAddresses.Clear();
 
                 try
                 {
-                    if (v.StartsWith('!'))
+                    IEnumerable<NetworkInterface> nics = NetworkInterface.GetAllNetworkInterfaces()
+                        .Where(i => i.SupportsMulticast && i.OperationalStatus == OperationalStatus.Up);
+
+                    foreach (NetworkInterface adapter in nics)
                     {
-                        if (negated)
+                        try
                         {
-                            AddToCollection(col, v[1..]);
-                        }
-                    }
-                    else if (!negated)
-                    {
-                        AddToCollection(col, v);
-                    }
-                }
-                catch (ArgumentException e)
-                {
-                    _logger.LogWarning(e, "Ignoring LAN value {Value}.", v);
-                }
-            }
-
-            return col;
-        }
-
-        /// <inheritdoc/>
-        public Collection<IPObject> GetAllBindInterfaces(bool individualInterfaces = false)
-        {
-            int count = _bindAddresses.Count;
+                            IPInterfaceProperties ipProperties = adapter.GetIPProperties();
+                            PhysicalAddress mac = adapter.GetPhysicalAddress();
 
-            if (count == 0)
-            {
-                if (_bindExclusions.Count > 0)
-                {
-                    // Return all the interfaces except the ones specifically excluded.
-                    return _interfaceAddresses.Exclude(_bindExclusions, false);
-                }
+                            // Populate MAC list
+                            if (adapter.NetworkInterfaceType != NetworkInterfaceType.Loopback && PhysicalAddress.None.Equals(mac))
+                            {
+                                _macAddresses.Add(mac);
+                            }
 
-                if (individualInterfaces)
-                {
-                    return new Collection<IPObject>(_interfaceAddresses);
-                }
+                            // Populate interface list
+                            foreach (UnicastIPAddressInformation info in ipProperties.UnicastAddresses)
+                            {
+                                if (IsIpv4Enabled && info.Address.AddressFamily == AddressFamily.InterNetwork)
+                                {
+                                    var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLength), adapter.Name);
+                                    interfaceObject.Index = ipProperties.GetIPv4Properties().Index;
+                                    interfaceObject.Name = adapter.Name.ToLower(CultureInfo.InvariantCulture);
 
-                // No bind address and no exclusions, so listen on all interfaces.
-                Collection<IPObject> result = new Collection<IPObject>();
+                                    _interfaces.Add(interfaceObject);
+                                }
+                                else if (IsIpv6Enabled && info.Address.AddressFamily == AddressFamily.InterNetworkV6)
+                                {
+                                    var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLength), adapter.Name);
+                                    interfaceObject.Index = ipProperties.GetIPv6Properties().Index;
+                                    interfaceObject.Name = adapter.Name.ToLower(CultureInfo.InvariantCulture);
 
-                if (IsIP6Enabled && IsIP4Enabled)
-                {
-                    // Kestrel source code shows it uses Sockets.DualMode - so this also covers IPAddress.Any
-                    result.AddItem(IPAddress.IPv6Any);
+                                    _interfaces.Add(interfaceObject);
+                                }
+                            }
+                        }
+#pragma warning disable CA1031 // Do not catch general exception types
+                        catch (Exception ex)
+#pragma warning restore CA1031 // Do not catch general exception types
+                        {
+                            // Ignore error, and attempt to continue.
+                            _logger.LogError(ex, "Error encountered parsing interfaces.");
+                        }
+                    }
                 }
-                else if (IsIP4Enabled)
+#pragma warning disable CA1031 // Do not catch general exception types
+                catch (Exception ex)
+#pragma warning restore CA1031 // Do not catch general exception types
                 {
-                    result.AddItem(IPAddress.Any);
+                    _logger.LogError(ex, "Error obtaining interfaces.");
                 }
-                else if (IsIP6Enabled)
+
+                // If for some reason we don't have an interface info, resolve the DNS name.
+                if (_interfaces.Count == 0)
                 {
-                    // Cannot use IPv6Any as Kestrel will bind to IPv4 addresses.
-                    foreach (var iface in _interfaceAddresses)
+                    _logger.LogError("No interfaces information available. Resolving DNS name.");
+                    var hostName = Dns.GetHostName();
+                    if (Uri.CheckHostName(hostName).Equals(UriHostNameType.Dns))
                     {
-                        if (iface.AddressFamily == AddressFamily.InterNetworkV6)
+                        try
+                        {
+                            IPHostEntry hip = Dns.GetHostEntry(hostName);
+                            foreach (var address in hip.AddressList)
+                            {
+                                _interfaces.Add(new IPData(address, null));
+                            }
+                        }
+                        catch (SocketException ex)
                         {
-                            result.AddItem(iface.Address);
+                            // Log and then ignore socket errors, as the result value will just be an empty array.
+                            _logger.LogWarning("GetHostEntryAsync failed with {Message}.", ex.Message);
                         }
                     }
-                }
-
-                return result;
-            }
-
-            // Remove any excluded bind interfaces.
-            return _bindAddresses.Exclude(_bindExclusions, false);
-        }
-
-        /// <inheritdoc/>
-        public string GetBindInterface(string source, out int? port)
-        {
-            if (!string.IsNullOrEmpty(source) && IPHost.TryParse(source, out IPHost host))
-            {
-                return GetBindInterface(host, out port);
-            }
-
-            return GetBindInterface(IPHost.None, out port);
-        }
-
-        /// <inheritdoc/>
-        public string GetBindInterface(IPAddress source, out int? port)
-        {
-            return GetBindInterface(new IPNetAddress(source), out port);
-        }
-
-        /// <inheritdoc/>
-        public string GetBindInterface(HttpRequest source, out int? port)
-        {
-            string result;
-
-            if (source != null && IPHost.TryParse(source.Host.Host, out IPHost host))
-            {
-                result = GetBindInterface(host, out port);
-                port ??= source.Host.Port;
-            }
-            else
-            {
-                result = GetBindInterface(IPNetAddress.None, out port);
-                port ??= source?.Host.Port;
-            }
-
-            return result;
-        }
-
-        /// <inheritdoc/>
-        public string GetBindInterface(IPObject source, out int? port)
-        {
-            port = null;
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            // Do we have a source?
-            bool haveSource = !source.Address.Equals(IPAddress.None);
-            bool isExternal = false;
 
-            if (haveSource)
-            {
-                if (!IsIP6Enabled && source.AddressFamily == AddressFamily.InterNetworkV6)
-                {
-                    _logger.LogWarning("IPv6 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected.");
+                    if (_interfaces.Count == 0)
+                    {
+                        _logger.LogWarning("No interfaces information available. Using loopback.");
+                    }
                 }
 
-                if (!IsIP4Enabled && source.AddressFamily == AddressFamily.InterNetwork)
+                if (IsIpv4Enabled && !IsIpv6Enabled)
                 {
-                    _logger.LogWarning("IPv4 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected.");
+                    _interfaces.Add(new IPData(IPAddress.Loopback, new IPNetwork(IPAddress.Loopback, 8), "lo"));
                 }
 
-                isExternal = !IsInLocalNetwork(source);
-
-                if (MatchesPublishedServerUrl(source, isExternal, out string res, out port))
+                if (!IsIpv4Enabled && IsIpv6Enabled)
                 {
-                    _logger.LogInformation("{Source}: Using BindAddress {Address}:{Port}", source, res, port);
-                    return res;
+                    _interfaces.Add(new IPData(IPAddress.IPv6Loopback, new IPNetwork(IPAddress.IPv6Loopback, 128), "lo"));
                 }
-            }
 
-            _logger.LogDebug("GetBindInterface: Source: {HaveSource}, External: {IsExternal}:", haveSource, isExternal);
-
-            // No preference given, so move on to bind addresses.
-            if (MatchesBindInterface(source, isExternal, out string result))
-            {
-                return result;
+                _logger.LogDebug("Discovered {0} interfaces.", _interfaces.Count);
+                _logger.LogDebug("Interfaces addresses : {0}", _interfaces.Select(s => s.Address).ToString());
             }
+        }
 
-            if (isExternal && MatchesExternalInterface(source, out result))
+        /// <summary>
+        /// Initialises internal LAN cache.
+        /// </summary>
+        private void InitialiseLan(NetworkConfiguration config)
+        {
+            lock (_initLock)
             {
-                return result;
-            }
+                _logger.LogDebug("Refreshing LAN information.");
 
-            // Get the first LAN interface address that isn't a loopback.
-            var interfaces = CreateCollection(
-                _interfaceAddresses
-                    .Exclude(_bindExclusions, false)
-                    .Where(IsInLocalNetwork)
-                    .OrderBy(p => p.Tag));
+                // Get configuration options
+                string[] subnets = config.LocalNetworkSubnets;
 
-            if (interfaces.Count > 0)
-            {
-                if (haveSource)
+                _ = TryParseSubnets(subnets, out _lanSubnets, false);
+                _ = TryParseSubnets(subnets, out _excludedSubnets, true);
+
+                if (_lanSubnets.Count == 0)
                 {
-                    foreach (var intf in interfaces)
+                    // If no LAN addresses are specified, all private subnets are deemed to be the LAN
+                    _logger.LogDebug("Using LAN interface addresses as user provided no LAN details.");
+
+                    if (IsIpv6Enabled)
                     {
-                        if (intf.Address.Equals(source.Address))
-                        {
-                            result = FormatIP6String(intf.Address);
-                            _logger.LogDebug("{Source}: GetBindInterface: Has found matching interface. {Result}", source, result);
-                            return result;
-                        }
+                        _lanSubnets.Add(new IPNetwork(IPAddress.Parse("fc00::"), 7)); // ULA
+                        _lanSubnets.Add(new IPNetwork(IPAddress.Parse("fe80::"), 10)); // Site local
                     }
 
-                    // Does the request originate in one of the interface subnets?
-                    // (For systems with multiple internal network cards, and multiple subnets)
-                    foreach (var intf in interfaces)
+                    if (IsIpv4Enabled)
                     {
-                        if (intf.Contains(source))
-                        {
-                            result = FormatIP6String(intf.Address);
-                            _logger.LogDebug("{Source}: GetBindInterface: Has source, matched best internal interface on range. {Result}", source, result);
-                            return result;
-                        }
+                        _lanSubnets.Add(new IPNetwork(IPAddress.Parse("10.0.0.0"), 8));
+                        _lanSubnets.Add(new IPNetwork(IPAddress.Parse("172.16.0.0"), 12));
+                        _lanSubnets.Add(new IPNetwork(IPAddress.Parse("192.168.0.0"), 16));
                     }
                 }
 
-                result = FormatIP6String(interfaces.First().Address);
-                _logger.LogDebug("{Source}: GetBindInterface: Matched first internal interface. {Result}", source, result);
-                return result;
+                _logger.LogInformation("Defined LAN addresses : {0}", _lanSubnets.Select(s => s.Prefix + "/" + s.PrefixLength));
+                _logger.LogInformation("Defined LAN exclusions : {0}", _excludedSubnets.Select(s => s.Prefix + "/" + s.PrefixLength));
+                _logger.LogInformation("Using LAN addresses: {0}", _lanSubnets.Where(s => !_excludedSubnets.Contains(s)).Select(s => s.Prefix + "/" + s.PrefixLength));
             }
-
-            // There isn't any others, so we'll use the loopback.
-            result = IsIP6Enabled ? "::1" : "127.0.0.1";
-            _logger.LogWarning("{Source}: GetBindInterface: Loopback {Result} returned.", source, result);
-            return result;
         }
 
-        /// <inheritdoc/>
-        public Collection<IPObject> GetInternalBindAddresses()
+        /// <summary>
+        /// Initialises the network bind addresses.
+        /// </summary>
+        private void InitialiseBind(NetworkConfiguration config)
         {
-            int count = _bindAddresses.Count;
-
-            if (count == 0)
+            lock (_initLock)
             {
-                if (_bindExclusions.Count > 0)
+                // Use explicit bind addresses
+                if (config.LocalNetworkAddresses.Length > 0)
                 {
-                    // Return all the internal interfaces except the ones excluded.
-                    return CreateCollection(_internalInterfaces.Where(p => !_bindExclusions.ContainsAddress(p)));
+                    _bindAddresses = config.LocalNetworkAddresses.Select(p => IPAddress.TryParse(p, out var address)
+                        ? address
+                        : (_interfaces.Where(x => x.Name.Equals(p, StringComparison.OrdinalIgnoreCase)).Select(x => x.Address).FirstOrDefault() ?? IPAddress.None)).ToList();
+                    _bindAddresses.RemoveAll(x => x == IPAddress.None);
+                }
+                else
+                {
+                    // Use all addresses from all interfaces
+                    _bindAddresses = _interfaces.Select(x => x.Address).ToList();
                 }
 
-                // No bind address, so return all internal interfaces.
-                return CreateCollection(_internalInterfaces);
-            }
-
-            return new Collection<IPObject>(_bindAddresses.Where(a => IsInLocalNetwork(a)).ToArray());
-        }
-
-        /// <inheritdoc/>
-        public bool IsInLocalNetwork(IPObject address)
-        {
-            return IsInLocalNetwork(address.Address);
-        }
+                _bindExclusions = new List<IPAddress>();
 
-        /// <inheritdoc/>
-        public bool IsInLocalNetwork(string address)
-        {
-            return IPHost.TryParse(address, out IPHost ipHost) && IsInLocalNetwork(ipHost);
-        }
+                // Add all interfaces matching any virtual machine interface prefix to _bindExclusions
+                if (config.IgnoreVirtualInterfaces)
+                {
+                    // Remove potentially exisiting * and split config string into prefixes
+                    var virtualInterfacePrefixes = config.VirtualInterfaceNames.Replace("*", string.Empty, StringComparison.OrdinalIgnoreCase).ToLower().Split(',');
 
-        /// <inheritdoc/>
-        public bool IsInLocalNetwork(IPAddress address)
-        {
-            if (address == null)
-            {
-                throw new ArgumentNullException(nameof(address));
-            }
+                    // Check all interfaces for matches against the prefixes and add the interface IPs to _bindExclusions
+                    if (_bindAddresses.Count > 0 && virtualInterfacePrefixes.Length > 0)
+                    {
+                        var localInterfaces = _interfaces.ToList();
+                        foreach (var virtualInterfacePrefix in virtualInterfacePrefixes)
+                        {
+                            var excludedInterfaceIps = localInterfaces.Where(intf => intf.Name.StartsWith(virtualInterfacePrefix, StringComparison.OrdinalIgnoreCase))
+                                .Select(intf => intf.Address);
+                            foreach (var interfaceIp in excludedInterfaceIps)
+                            {
+                                _bindExclusions.Add(interfaceIp);
+                            }
+                        }
+                    }
+                }
 
-            if (address.Equals(IPAddress.None))
-            {
-                return false;
-            }
+                // Remove all excluded addresses from _bindAddresses
+                _bindAddresses.RemoveAll(x => _bindExclusions.Contains(x));
 
-            // See conversation at https://github.com/jellyfin/jellyfin/pull/3515.
-            if (TrustAllIP6Interfaces && address.AddressFamily == AddressFamily.InterNetworkV6)
-            {
-                return true;
+                _logger.LogInformation("Using bind addresses: {0}", _bindAddresses);
+                _logger.LogInformation("Using bind exclusions: {0}", _bindExclusions);
             }
-
-            // As private addresses can be redefined by Configuration.LocalNetworkAddresses
-            return IPAddress.IsLoopback(address) || (_lanSubnets.ContainsAddress(address) && !_excludedSubnets.ContainsAddress(address));
         }
 
-        /// <inheritdoc/>
-        public bool IsPrivateAddressRange(IPObject address)
+        /// <summary>
+        /// Initialises the remote address values.
+        /// </summary>
+        private void InitialiseRemote(NetworkConfiguration config)
         {
-            if (address == null)
+            lock (_initLock)
             {
-                throw new ArgumentNullException(nameof(address));
-            }
-
-            // See conversation at https://github.com/jellyfin/jellyfin/pull/3515.
-            if (TrustAllIP6Interfaces && address.AddressFamily == AddressFamily.InterNetworkV6)
-            {
-                return true;
-            }
-            else
-            {
-                return address.IsPrivateAddressRange();
-            }
-        }
-
-        /// <inheritdoc/>
-        public bool IsExcludedInterface(IPAddress address)
-        {
-            return _bindExclusions.ContainsAddress(address);
-        }
+                // Parse config values into filter collection
+                var remoteIPFilter = config.RemoteIPFilter;
+                if (remoteIPFilter.Any() && !string.IsNullOrWhiteSpace(remoteIPFilter.First()))
+                {
+                    // Parse all IPs with netmask to a subnet
+                    _ = TryParseSubnets(remoteIPFilter.Where(x => x.Contains("/", StringComparison.OrdinalIgnoreCase)).ToArray(), out _remoteAddressFilter, false);
 
-        /// <inheritdoc/>
-        public Collection<IPObject> GetFilteredLANSubnets(Collection<IPObject>? filter = null)
-        {
-            if (filter == null)
-            {
-                return _lanSubnets.Exclude(_excludedSubnets, true).AsNetworks();
+                    // Parse everything else as an IP and construct subnet with a single IP
+                    var ips = remoteIPFilter.Where(x => !x.Contains("/", StringComparison.OrdinalIgnoreCase));
+                    foreach (var ip in ips)
+                    {
+                        if (IPAddress.TryParse(ip, out var ipp))
+                        {
+                            _remoteAddressFilter.Add(new IPNetwork(ipp, ipp.AddressFamily == AddressFamily.InterNetwork ? 32 : 128));
+                        }
+                    }
+                }
             }
-
-            return _lanSubnets.Exclude(filter, true);
-        }
-
-        /// <inheritdoc/>
-        public bool IsValidInterfaceAddress(IPAddress address)
-        {
-            return _interfaceAddresses.ContainsAddress(address);
         }
 
-        /// <inheritdoc/>
-        public bool TryParseInterface(string token, out Collection<IPObject>? result)
+        /// <summary>
+        /// Parses the user defined overrides into the dictionary object.
+        /// Overrides are the equivalent of localised publishedServerUrl, enabling
+        /// different addresses to be advertised over different subnets.
+        /// format is subnet=ipaddress|host|uri
+        /// when subnet = 0.0.0.0, any external address matches.
+        /// </summary>
+        private void InitialiseOverrides(NetworkConfiguration config)
         {
-            result = null;
-            if (string.IsNullOrEmpty(token))
-            {
-                return false;
-            }
-
-            if (_interfaceNames != null && _interfaceNames.TryGetValue(token.ToLower(CultureInfo.InvariantCulture), out int index))
+            lock (_initLock)
             {
-                result = new Collection<IPObject>();
-
-                _logger.LogInformation("Interface {Token} used in settings. Using its interface addresses.", token);
+                _publishedServerUrls.Clear();
+                string[] overrides = config.PublishedServerUriBySubnet;
 
-                // Replace interface tags with the interface IP's.
-                foreach (IPNetAddress iface in _interfaceAddresses)
+                foreach (var entry in overrides)
                 {
-                    if (Math.Abs(iface.Tag) == index
-                        && ((IsIP4Enabled && iface.Address.AddressFamily == AddressFamily.InterNetwork)
-                            || (IsIP6Enabled && iface.Address.AddressFamily == AddressFamily.InterNetworkV6)))
+                    var parts = entry.Split('=');
+                    if (parts.Length != 2)
                     {
-                        result.AddItem(iface, false);
+                        _logger.LogError("Unable to parse bind override: {Entry}", entry);
                     }
-                }
+                    else
+                    {
+                        var replacement = parts[1].Trim();
+                        var ipParts = parts[0].Split("/");
+                        if (string.Equals(parts[0], "all", StringComparison.OrdinalIgnoreCase))
+                        {
+                            _publishedServerUrls[new IPData(IPAddress.Broadcast, null)] = replacement;
+                        }
+                        else if (string.Equals(parts[0], "external", StringComparison.OrdinalIgnoreCase))
+                        {
+                            _publishedServerUrls[new IPData(IPAddress.Any, new IPNetwork(IPAddress.Any, 0))] = replacement;
+                            _publishedServerUrls[new IPData(IPAddress.IPv6Any, new IPNetwork(IPAddress.IPv6Any, 0))] = replacement;
+                        }
+                        else if (IPAddress.TryParse(ipParts[0], out IPAddress? result))
+                        {
+                            var data = new IPData(result, null);
+                            if (ipParts.Length > 1 && int.TryParse(ipParts[1], out var netmask))
+                            {
+                                data.Subnet = new IPNetwork(result, netmask);
+                            }
 
-                return true;
+                            _publishedServerUrls[data] = replacement;
+                        }
+                        else if (TryParseInterface(parts[0], out var ifaces))
+                        {
+                            foreach (var iface in ifaces)
+                            {
+                                _publishedServerUrls[iface] = replacement;
+                            }
+                        }
+                        else
+                        {
+                            _logger.LogError("Unable to parse bind ip address. {Parts}", parts[1]);
+                        }
+                    }
+                }
             }
-
-            return false;
         }
 
-        /// <inheritdoc/>
-        public bool HasRemoteAccess(IPAddress remoteIp)
+        private void ConfigurationUpdated(object? sender, ConfigurationUpdateEventArgs evt)
         {
-            var config = _configurationManager.GetNetworkConfiguration();
-            if (config.EnableRemoteAccess)
-            {
-                // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
-                // If left blank, all remote addresses will be allowed.
-                if (RemoteAddressFilter.Count > 0 && !IsInLocalNetwork(remoteIp))
-                {
-                    // remoteAddressFilter is a whitelist or blacklist.
-                    return RemoteAddressFilter.ContainsAddress(remoteIp) == !config.IsRemoteIPFilterBlacklist;
-                }
-            }
-            else if (!IsInLocalNetwork(remoteIp))
+            if (evt.Key.Equals("network", StringComparison.Ordinal))
             {
-                // Remote not enabled. So everyone should be LAN.
-                return false;
+                UpdateSettings((NetworkConfiguration)evt.NewConfiguration);
             }
-
-            return true;
         }
 
         /// <summary>
@@ -601,17 +510,6 @@ namespace Jellyfin.Networking.Manager
         {
             NetworkConfiguration config = (NetworkConfiguration)configuration ?? throw new ArgumentNullException(nameof(configuration));
 
-            IsIP4Enabled = Socket.OSSupportsIPv4 && config.EnableIPV4;
-            IsIP6Enabled = Socket.OSSupportsIPv6 && config.EnableIPV6;
-
-            if (!IsIP6Enabled && !IsIP4Enabled)
-            {
-                _logger.LogError("IPv4 and IPv6 cannot both be disabled.");
-                IsIP4Enabled = true;
-            }
-
-            TrustAllIP6Interfaces = config.TrustAllIP6Interfaces;
-
             if (string.IsNullOrEmpty(MockNetworkSettings))
             {
                 InitialiseInterfaces();
@@ -623,15 +521,22 @@ namespace Jellyfin.Networking.Manager
                 foreach (var details in interfaceList)
                 {
                     var parts = details.Split(',');
-                    var address = IPNetAddress.Parse(parts[0]);
+                    var split = parts[0].Split("/");
+                    var address = IPAddress.Parse(split[0]);
+                    var network = new IPNetwork(address, int.Parse(split[1], CultureInfo.InvariantCulture));
                     var index = int.Parse(parts[1], CultureInfo.InvariantCulture);
-                    address.Tag = index;
-                    _interfaceAddresses.AddItem(address, false);
-                    _interfaceNames[parts[2]] = Math.Abs(index);
+                    if (address.AddressFamily == AddressFamily.InterNetwork)
+                    {
+                        _interfaces.Add(new IPData(address, network, parts[2]));
+                    }
+                    else if (address.AddressFamily == AddressFamily.InterNetworkV6)
+                    {
+                        _interfaces.Add(new IPData(address, network, parts[2]));
+                    }
                 }
             }
 
-            InitialiseLAN(config);
+            InitialiseLan(config);
             InitialiseBind(config);
             InitialiseRemote(config);
             InitialiseOverrides(config);
@@ -656,540 +561,467 @@ namespace Jellyfin.Networking.Manager
             }
         }
 
-        /// <summary>
-        /// Tries to identify the string and return an object of that class.
-        /// </summary>
-        /// <param name="addr">String to parse.</param>
-        /// <param name="result">IPObject to return.</param>
-        /// <returns><c>true</c> if the value parsed successfully, <c>false</c> otherwise.</returns>
-        private static bool TryParse(string addr, out IPObject result)
+        /// <inheritdoc/>
+        public bool TryParseInterface(string intf, out Collection<IPData> result)
         {
-            if (!string.IsNullOrEmpty(addr))
+            result = new Collection<IPData>();
+            if (string.IsNullOrEmpty(intf))
             {
-                // Is it an IP address
-                if (IPNetAddress.TryParse(addr, out IPNetAddress nw))
-                {
-                    result = nw;
-                    return true;
-                }
+                return false;
+            }
 
-                if (IPHost.TryParse(addr, out IPHost h))
+            if (_interfaces != null)
+            {
+                // Match all interfaces starting with names starting with token
+                var matchedInterfaces = _interfaces.Where(s => s.Name.Equals(intf.ToLower(CultureInfo.InvariantCulture), StringComparison.OrdinalIgnoreCase));
+                if (matchedInterfaces.Any())
                 {
-                    result = h;
+                    _logger.LogInformation("Interface {Token} used in settings. Using its interface addresses.", intf);
+
+                    // Use interface IP instead of name
+                    foreach (IPData iface in matchedInterfaces)
+                    {
+                        if ((IsIpv4Enabled && iface.Address.AddressFamily == AddressFamily.InterNetwork)
+                            || (IsIpv6Enabled && iface.Address.AddressFamily == AddressFamily.InterNetworkV6))
+                        {
+                            result.Add(iface);
+                        }
+                    }
+
                     return true;
                 }
             }
 
-            result = IPNetAddress.None;
             return false;
         }
 
         /// <summary>
-        /// Converts an IPAddress into a string.
-        /// Ipv6 addresses are returned in [ ], with their scope removed.
+        /// Try parsing an array of strings into subnets, respecting exclusions.
         /// </summary>
-        /// <param name="address">Address to convert.</param>
-        /// <returns>URI safe conversion of the address.</returns>
-        private static string FormatIP6String(IPAddress address)
+        /// <param name="values">Input string to be parsed.</param>
+        /// <param name="result">Collection of <see cref="IPNetwork"/>.</param>
+        /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
+        /// <returns><c>True</c> if parsing was successful.</returns>
+        public bool TryParseSubnets(string[] values, out Collection<IPNetwork> result, bool negated = false)
         {
-            var str = address.ToString();
-            if (address.AddressFamily == AddressFamily.InterNetworkV6)
+            result = new Collection<IPNetwork>();
+
+            if (values == null || values.Length == 0)
             {
-                int i = str.IndexOf("%", StringComparison.OrdinalIgnoreCase);
-                if (i != -1)
+                return false;
+            }
+
+            for (int a = 0; a < values.Length; a++)
+            {
+                string[] v = values[a].Trim().Split("/");
+
+                try
+                {
+                    var address = IPAddress.None;
+                    if (negated && v[0].StartsWith('!'))
+                    {
+                        _ = IPAddress.TryParse(v[0][1..], out address);
+                    }
+                    else if (!negated)
+                    {
+                        _ = IPAddress.TryParse(v[0][0..], out address);
+                    }
+
+                    if (address != IPAddress.None && address != null)
+                    {
+                        if (int.TryParse(v[1], out var netmask))
+                        {
+                            result.Add(new IPNetwork(address, netmask));
+                        }
+                        else if (address.AddressFamily == AddressFamily.InterNetwork)
+                        {
+                            result.Add(new IPNetwork(address, 32));
+                        }
+                        else if (address.AddressFamily == AddressFamily.InterNetworkV6)
+                        {
+                            result.Add(new IPNetwork(address, 128));
+                        }
+                    }
+                }
+                catch (ArgumentException e)
                 {
-                    str = str.Substring(0, i);
+                    _logger.LogWarning(e, "Ignoring LAN value {Value}.", v);
                 }
+            }
 
-                return $"[{str}]";
+            if (result.Count > 0)
+            {
+                return true;
             }
 
-            return str;
+            return false;
         }
 
-        private void ConfigurationUpdated(object? sender, ConfigurationUpdateEventArgs evt)
+        /// <inheritdoc/>
+        public bool HasRemoteAccess(IPAddress remoteIp)
         {
-            if (evt.Key.Equals(NetworkConfigurationStore.StoreKey, StringComparison.Ordinal))
+            var config = _configurationManager.GetNetworkConfiguration();
+            if (config.EnableRemoteAccess)
             {
-                UpdateSettings((NetworkConfiguration)evt.NewConfiguration);
+                // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
+                // If left blank, all remote addresses will be allowed.
+                if (_remoteAddressFilter.Any() && !_lanSubnets.Any(x => x.Contains(remoteIp)))
+                {
+                    // remoteAddressFilter is a whitelist or blacklist.
+                    var matches = _remoteAddressFilter.Count(remoteNetwork => remoteNetwork.Contains(remoteIp));
+                    if ((!config.IsRemoteIPFilterBlacklist && matches > 0)
+                        || (config.IsRemoteIPFilterBlacklist && matches == 0))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+            }
+            else if (!_lanSubnets.Where(x => x.Contains(remoteIp)).Any())
+            {
+                // Remote not enabled. So everyone should be LAN.
+                return false;
             }
+
+            return true;
         }
 
-        /// <summary>
-        /// Checks the string to see if it matches any interface names.
-        /// </summary>
-        /// <param name="token">String to check.</param>
-        /// <param name="index">Interface index numbers that match.</param>
-        /// <returns><c>true</c> if an interface name matches the token, <c>False</c> otherwise.</returns>
-        private bool TryGetInterfaces(string token, [NotNullWhen(true)] out List<int>? index)
+        /// <inheritdoc/>
+        public IReadOnlyCollection<PhysicalAddress> GetMacAddresses()
         {
-            index = null;
+            // Populated in construction - so always has values.
+            return _macAddresses;
+        }
 
-            // Is it the name of an interface (windows) eg, Wireless LAN adapter Wireless Network Connection 1.
-            // Null check required here for automated testing.
-            if (_interfaceNames != null && token.Length > 1)
+        /// <inheritdoc/>
+        public List<IPData> GetLoopbacks()
+        {
+            var loopbackNetworks = new List<IPData>();
+            if (IsIpv4Enabled)
             {
-                bool partial = token[^1] == '*';
-                if (partial)
-                {
-                    token = token[..^1];
-                }
+                loopbackNetworks.Add(new IPData(IPAddress.Loopback, new IPNetwork(IPAddress.Loopback, 8), "lo"));
+            }
 
-                foreach ((string interfc, int interfcIndex) in _interfaceNames)
-                {
-                    if ((!partial && string.Equals(interfc, token, StringComparison.OrdinalIgnoreCase))
-                        || (partial && interfc.StartsWith(token, true, CultureInfo.InvariantCulture)))
-                    {
-                        index ??= new List<int>();
-                        index.Add(interfcIndex);
-                    }
-                }
+            if (IsIpv6Enabled)
+            {
+                loopbackNetworks.Add(new IPData(IPAddress.IPv6Loopback, new IPNetwork(IPAddress.IPv6Loopback, 128), "lo"));
             }
 
-            return index != null;
+            return loopbackNetworks;
         }
 
-        /// <summary>
-        /// Parses a string and adds it into the collection, replacing any interface references.
-        /// </summary>
-        /// <param name="col"><see cref="Collection{IPObject}"/>Collection.</param>
-        /// <param name="token">String value to parse.</param>
-        private void AddToCollection(Collection<IPObject> col, string token)
+        /// <inheritdoc/>
+        public List<IPData> GetAllBindInterfaces(bool individualInterfaces = false)
         {
-            // Is it the name of an interface (windows) eg, Wireless LAN adapter Wireless Network Connection 1.
-            // Null check required here for automated testing.
-            if (TryGetInterfaces(token, out var indices))
+            if (_bindAddresses.Count == 0)
             {
-                _logger.LogInformation("Interface {Token} used in settings. Using its interface addresses.", token);
-
-                // Replace all the interface tags with the interface IP's.
-                foreach (IPNetAddress iface in _interfaceAddresses)
+                if (_bindExclusions.Count > 0)
                 {
-                    if (indices.Contains(Math.Abs(iface.Tag))
-                        && ((IsIP4Enabled && iface.Address.AddressFamily == AddressFamily.InterNetwork)
-                            || (IsIP6Enabled && iface.Address.AddressFamily == AddressFamily.InterNetworkV6)))
+                    foreach (var exclusion in _bindExclusions)
                     {
-                        col.AddItem(iface);
+                        // Return all the interfaces except the ones specifically excluded.
+                        _interfaces.RemoveAll(intf => intf.Address == exclusion);
                     }
+
+                    return _interfaces;
                 }
-            }
-            else if (TryParse(token, out IPObject obj))
-            {
-                // Expand if the ip address is "any".
-                if ((obj.Address.Equals(IPAddress.Any) && IsIP4Enabled)
-                    || (obj.Address.Equals(IPAddress.IPv6Any) && IsIP6Enabled))
+
+                // No bind address and no exclusions, so listen on all interfaces.
+                var result = new List<IPData>();
+
+                if (individualInterfaces)
                 {
-                    foreach (IPNetAddress iface in _interfaceAddresses)
+                    foreach (var iface in _interfaces)
                     {
-                        if (obj.AddressFamily == iface.AddressFamily)
-                        {
-                            col.AddItem(iface);
-                        }
+                        result.Add(iface);
                     }
+
+                    return result;
                 }
-                else if (!IsIP6Enabled)
+
+                if (IsIpv4Enabled && IsIpv6Enabled)
                 {
-                    // Remove IP6 addresses from multi-homed IPHosts.
-                    obj.Remove(AddressFamily.InterNetworkV6);
-                    if (!obj.IsIP6())
-                    {
-                        col.AddItem(obj);
-                    }
+                    // Kestrel source code shows it uses Sockets.DualMode - so this also covers IPAddress.Any by default
+                    result.Add(new IPData(IPAddress.IPv6Any, new IPNetwork(IPAddress.IPv6Any, 0)));
                 }
-                else if (!IsIP4Enabled)
+                else if (IsIpv4Enabled)
                 {
-                    // Remove IP4 addresses from multi-homed IPHosts.
-                    obj.Remove(AddressFamily.InterNetwork);
-                    if (obj.IsIP6())
-                    {
-                        col.AddItem(obj);
-                    }
+                    result.Add(new IPData(IPAddress.Any, new IPNetwork(IPAddress.Any, 0)));
                 }
-                else
+                else if (IsIpv6Enabled)
                 {
-                    col.AddItem(obj);
+                    // Cannot use IPv6Any as Kestrel will bind to IPv4 addresses too.
+                    foreach (var iface in _interfaces)
+                    {
+                        if (iface.AddressFamily == AddressFamily.InterNetworkV6)
+                        {
+                            result.Add(iface);
+                        }
+                    }
                 }
+
+                return result;
             }
-            else
+
+            // Remove any excluded bind interfaces.
+            foreach (var exclusion in _bindExclusions)
             {
-                _logger.LogDebug("Invalid or unknown object {Token}.", token);
+                // Return all the interfaces except the ones specifically excluded.
+                _bindAddresses.Remove(exclusion);
             }
-        }
 
-        /// <summary>
-        /// Handler for network change events.
-        /// </summary>
-        /// <param name="sender">Sender.</param>
-        /// <param name="e">A <see cref="NetworkAvailabilityEventArgs"/> containing network availability information.</param>
-        private void OnNetworkAvailabilityChanged(object? sender, NetworkAvailabilityEventArgs e)
-        {
-            _logger.LogDebug("Network availability changed.");
-            OnNetworkChanged();
+            return _bindAddresses.Select(s => new IPData(s, null)).ToList();
         }
 
-        /// <summary>
-        /// Handler for network change events.
-        /// </summary>
-        /// <param name="sender">Sender.</param>
-        /// <param name="e">An <see cref="EventArgs"/>.</param>
-        private void OnNetworkAddressChanged(object? sender, EventArgs e)
+        /// <inheritdoc/>
+        public string GetBindInterface(string source, out int? port)
         {
-            _logger.LogDebug("Network address change detected.");
-            OnNetworkChanged();
+            _ = NetworkExtensions.TryParseHost(source, out var address, IsIpv4Enabled, IsIpv6Enabled);
+            var result = GetBindInterface(address.FirstOrDefault(), out port);
+            return result;
         }
 
-        /// <summary>
-        /// Async task that waits for 2 seconds before re-initialising the settings, as typically these events fire multiple times in succession.
-        /// </summary>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        private async Task OnNetworkChangeAsync()
+        /// <inheritdoc/>
+        public string GetBindInterface(HttpRequest source, out int? port)
         {
-            try
-            {
-                await Task.Delay(2000).ConfigureAwait(false);
-                InitialiseInterfaces();
-                // Recalculate LAN caches.
-                InitialiseLAN(_configurationManager.GetNetworkConfiguration());
+            string result;
+            _ = NetworkExtensions.TryParseHost(source.Host.Host, out var addresses, IsIpv4Enabled, IsIpv6Enabled);
+            result = GetBindInterface(addresses.FirstOrDefault(), out port);
+            port ??= source.Host.Port;
 
-                NetworkChanged?.Invoke(this, EventArgs.Empty);
-            }
-            finally
-            {
-                _eventfire = false;
-            }
+            return result;
         }
 
-        /// <summary>
-        /// Triggers our event, and re-loads interface information.
-        /// </summary>
-        private void OnNetworkChanged()
+        /// <inheritdoc/>
+        public string GetBindInterface(IPAddress? source, out int? port)
         {
-            lock (_eventFireLock)
+            port = null;
+
+            string result;
+
+            if (source != null)
             {
-                if (!_eventfire)
+                if (IsIpv4Enabled && source.AddressFamily == AddressFamily.InterNetworkV6)
                 {
-                    _logger.LogDebug("Network Address Change Event.");
-                    // As network events tend to fire one after the other only fire once every second.
-                    _eventfire = true;
-                    OnNetworkChangeAsync().GetAwaiter().GetResult();
+                    _logger.LogWarning("IPv6 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected.");
                 }
-            }
-        }
 
-        /// <summary>
-        /// Parses the user defined overrides into the dictionary object.
-        /// Overrides are the equivalent of localised publishedServerUrl, enabling
-        /// different addresses to be advertised over different subnets.
-        /// format is subnet=ipaddress|host|uri
-        /// when subnet = 0.0.0.0, any external address matches.
-        /// </summary>
-        private void InitialiseOverrides(NetworkConfiguration config)
-        {
-            lock (_intLock)
-            {
-                _publishedServerUrls.Clear();
-                string[] overrides = config.PublishedServerUriBySubnet;
-                if (overrides == null)
+                if (IsIpv6Enabled && source.AddressFamily == AddressFamily.InterNetwork)
+                {
+                    _logger.LogWarning("IPv4 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected.");
+                }
+
+                bool isExternal = !_lanSubnets.Any(network => network.Contains(source));
+                _logger.LogDebug("GetBindInterface with source. External: {IsExternal}:", isExternal);
+
+                if (MatchesPublishedServerUrl(source, isExternal, out string res, out port))
                 {
-                    return;
+                    _logger.LogInformation("{Source}: Using BindAddress {Address}:{Port}", source, res, port);
+                    return res;
                 }
 
-                foreach (var entry in overrides)
+                // No preference given, so move on to bind addresses.
+                if (MatchesBindInterface(source, isExternal, out result))
                 {
-                    var parts = entry.Split('=');
-                    if (parts.Length != 2)
-                    {
-                        _logger.LogError("Unable to parse bind override: {Entry}", entry);
-                    }
-                    else
+                    return result;
+                }
+
+                if (isExternal && MatchesExternalInterface(source, out result))
+                {
+                    return result;
+                }
+            }
+
+            // Get the first LAN interface address that's not excluded and not a loopback address.
+            var availableInterfaces = _interfaces.Where(x => !IPAddress.IsLoopback(x.Address))
+                .OrderByDescending(x => _bindAddresses.Contains(x.Address))
+                .ThenByDescending(x => IsInLocalNetwork(x.Address))
+                .ThenBy(x => x.Index);
+
+            if (availableInterfaces.Any())
+            {
+                if (source != null)
+                {
+                    foreach (var intf in availableInterfaces)
                     {
-                        var replacement = parts[1].Trim();
-                        if (string.Equals(parts[0], "all", StringComparison.OrdinalIgnoreCase))
+                        if (intf.Address.Equals(source))
                         {
-                            _publishedServerUrls[new IPNetAddress(IPAddress.Broadcast)] = replacement;
-                        }
-                        else if (string.Equals(parts[0], "external", StringComparison.OrdinalIgnoreCase))
-                        {
-                            _publishedServerUrls[new IPNetAddress(IPAddress.Any)] = replacement;
-                        }
-                        else if (TryParseInterface(parts[0], out Collection<IPObject>? addresses) && addresses != null)
-                        {
-                            foreach (IPNetAddress na in addresses)
-                            {
-                                _publishedServerUrls[na] = replacement;
-                            }
-                        }
-                        else if (IPNetAddress.TryParse(parts[0], out IPNetAddress result))
-                        {
-                            _publishedServerUrls[result] = replacement;
+                            result = NetworkExtensions.FormatIpString(intf.Address);
+                            _logger.LogDebug("{Source}: GetBindInterface: Has found matching interface. {Result}", source, result);
+                            return result;
                         }
-                        else
+                    }
+
+                    // Does the request originate in one of the interface subnets?
+                    // (For systems with multiple internal network cards, and multiple subnets)
+                    foreach (var intf in availableInterfaces)
+                    {
+                        if (intf.Subnet.Contains(source))
                         {
-                            _logger.LogError("Unable to parse bind ip address. {Parts}", parts[1]);
+                            result = NetworkExtensions.FormatIpString(intf.Address);
+                            _logger.LogDebug("{Source}: GetBindInterface: Has source, matched best internal interface on range. {Result}", source, result);
+                            return result;
                         }
                     }
                 }
+
+                result = NetworkExtensions.FormatIpString(availableInterfaces.First().Address);
+                _logger.LogDebug("{Source}: GetBindInterface: Matched first internal interface. {Result}", source, result);
+                return result;
             }
+
+            // There isn't any others, so we'll use the loopback.
+            result = IsIpv4Enabled && !IsIpv6Enabled ? "127.0.0.1" : "::1";
+            _logger.LogWarning("{Source}: GetBindInterface: Loopback {Result} returned.", source, result);
+            return result;
         }
 
-        /// <summary>
-        /// Initialises the network bind addresses.
-        /// </summary>
-        private void InitialiseBind(NetworkConfiguration config)
+        /// <inheritdoc/>
+        public List<IPData> GetInternalBindAddresses()
         {
-            lock (_intLock)
+            if (_bindAddresses.Count == 0)
             {
-                string[] lanAddresses = config.LocalNetworkAddresses;
-
-                // Add virtual machine interface names to the list of bind exclusions, so that they are auto-excluded.
-                if (config.IgnoreVirtualInterfaces)
+                if (_bindExclusions.Count > 0)
                 {
-                    // each virtual interface name must be pre-pended with the exclusion symbol !
-                    var virtualInterfaceNames = config.VirtualInterfaceNames.Split(',').Select(p => "!" + p).ToArray();
-                    if (lanAddresses.Length > 0)
-                    {
-                        var newList = new string[lanAddresses.Length + virtualInterfaceNames.Length];
-                        Array.Copy(lanAddresses, newList, lanAddresses.Length);
-                        Array.Copy(virtualInterfaceNames, 0, newList, lanAddresses.Length, virtualInterfaceNames.Length);
-                        lanAddresses = newList;
-                    }
-                    else
-                    {
-                        lanAddresses = virtualInterfaceNames;
-                    }
+                    // Return all the internal interfaces except the ones excluded.
+                    return _interfaces.Where(p => !_bindExclusions.Contains(p.Address)).ToList();
                 }
 
-                // Read and parse bind addresses and exclusions, removing ones that don't exist.
-                _bindAddresses = CreateIPCollection(lanAddresses).ThatAreContainedInNetworks(_interfaceAddresses);
-                _bindExclusions = CreateIPCollection(lanAddresses, true).ThatAreContainedInNetworks(_interfaceAddresses);
-                _logger.LogInformation("Using bind addresses: {0}", _bindAddresses.AsString());
-                _logger.LogInformation("Using bind exclusions: {0}", _bindExclusions.AsString());
+                // No bind address, so return all internal interfaces.
+                return _interfaces;
             }
+
+            // Select all local bind addresses
+            return _interfaces.Where(x => _bindAddresses.Contains(x.Address))
+                .Where(x => IsInLocalNetwork(x.Address))
+                .OrderBy(x => x.Index).ToList();
         }
 
-        /// <summary>
-        /// Initialises the remote address values.
-        /// </summary>
-        private void InitialiseRemote(NetworkConfiguration config)
+        /// <inheritdoc/>
+        public bool IsInLocalNetwork(string address)
         {
-            lock (_intLock)
+            if (IPAddress.TryParse(address, out var ep))
             {
-                RemoteAddressFilter = CreateIPCollection(config.RemoteIPFilter);
+                return IPAddress.IsLoopback(ep) || (_lanSubnets.Any(x => x.Contains(ep)) && !_excludedSubnets.Any(x => x.Contains(ep)));
             }
-        }
 
-        /// <summary>
-        /// Initialises internal LAN cache settings.
-        /// </summary>
-        private void InitialiseLAN(NetworkConfiguration config)
-        {
-            lock (_intLock)
+            if (NetworkExtensions.TryParseHost(address, out var addresses, IsIpv4Enabled, IsIpv6Enabled))
             {
-                _logger.LogDebug("Refreshing LAN information.");
-
-                // Get configuration options.
-                string[] subnets = config.LocalNetworkSubnets;
-
-                // Create lists from user settings.
-
-                _lanSubnets = CreateIPCollection(subnets);
-                _excludedSubnets = CreateIPCollection(subnets, true).AsNetworks();
-
-                // If no LAN addresses are specified - all private subnets are deemed to be the LAN
-                _usingPrivateAddresses = _lanSubnets.Count == 0;
-
-                // NOTE: The order of the commands generating the collection in this statement matters.
-                // Altering the order will cause the collections to be created incorrectly.
-                if (_usingPrivateAddresses)
+                bool match = false;
+                foreach (var ept in addresses)
                 {
-                    _logger.LogDebug("Using LAN interface addresses as user provided no LAN details.");
-                    // Internal interfaces must be private and not excluded.
-                    _internalInterfaces = CreateCollection(_interfaceAddresses.Where(i => IsPrivateAddressRange(i) && !_excludedSubnets.ContainsAddress(i)));
-
-                    // Subnets are the same as the calculated internal interface.
-                    _lanSubnets = new Collection<IPObject>();
-
-                    if (IsIP6Enabled)
-                    {
-                        _lanSubnets.AddItem(IPNetAddress.Parse("fc00::/7")); // ULA
-                        _lanSubnets.AddItem(IPNetAddress.Parse("fe80::/10")); // Site local
-                    }
-
-                    if (IsIP4Enabled)
-                    {
-                        _lanSubnets.AddItem(IPNetAddress.Parse("10.0.0.0/8"));
-                        _lanSubnets.AddItem(IPNetAddress.Parse("172.16.0.0/12"));
-                        _lanSubnets.AddItem(IPNetAddress.Parse("192.168.0.0/16"));
-                    }
-                }
-                else
-                {
-                    // Internal interfaces must be private, not excluded and part of the LocalNetworkSubnet.
-                    _internalInterfaces = CreateCollection(_interfaceAddresses.Where(IsInLocalNetwork));
+                    match |= IPAddress.IsLoopback(ept) || (_lanSubnets.Any(x => x.Contains(ept)) && !_excludedSubnets.Any(x => x.Contains(ept)));
                 }
 
-                _logger.LogInformation("Defined LAN addresses : {0}", _lanSubnets.AsString());
-                _logger.LogInformation("Defined LAN exclusions : {0}", _excludedSubnets.AsString());
-                _logger.LogInformation("Using LAN addresses: {0}", _lanSubnets.Exclude(_excludedSubnets, true).AsNetworks().AsString());
+                return match;
             }
+
+            return false;
         }
 
-        /// <summary>
-        /// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
-        /// Generate a list of all active mac addresses that aren't loopback addresses.
-        /// </summary>
-        private void InitialiseInterfaces()
+        /// <inheritdoc/>
+        public bool IsInLocalNetwork(IPAddress address)
         {
-            lock (_intLock)
+            if (address == null)
             {
-                _logger.LogDebug("Refreshing interfaces.");
-
-                _interfaceNames.Clear();
-                _interfaceAddresses.Clear();
-                _macAddresses.Clear();
+                throw new ArgumentNullException(nameof(address));
+            }
 
-                try
-                {
-                    IEnumerable<NetworkInterface> nics = NetworkInterface.GetAllNetworkInterfaces()
-                        .Where(i => i.SupportsMulticast && i.OperationalStatus == OperationalStatus.Up);
+            // See conversation at https://github.com/jellyfin/jellyfin/pull/3515.
+            if (TrustAllIpv6Interfaces && address.AddressFamily == AddressFamily.InterNetworkV6)
+            {
+                return true;
+            }
 
-                    foreach (NetworkInterface adapter in nics)
-                    {
-                        try
-                        {
-                            IPInterfaceProperties ipProperties = adapter.GetIPProperties();
-                            PhysicalAddress mac = adapter.GetPhysicalAddress();
+            // As private addresses can be redefined by Configuration.LocalNetworkAddresses
+            var match = CheckIfLanAndNotExcluded(address);
 
-                            // populate mac list
-                            if (adapter.NetworkInterfaceType != NetworkInterfaceType.Loopback && mac != null && mac != PhysicalAddress.None)
-                            {
-                                _macAddresses.Add(mac);
-                            }
+            return address.Equals(IPAddress.Loopback) || address.Equals(IPAddress.IPv6Loopback) || match;
+        }
 
-                            // populate interface address list
-                            foreach (UnicastIPAddressInformation info in ipProperties.UnicastAddresses)
-                            {
-                                if (IsIP4Enabled && info.Address.AddressFamily == AddressFamily.InterNetwork)
-                                {
-                                    IPNetAddress nw = new IPNetAddress(info.Address, IPObject.MaskToCidr(info.IPv4Mask))
-                                    {
-                                        // Keep the number of gateways on this interface, along with its index.
-                                        Tag = ipProperties.GetIPv4Properties().Index
-                                    };
-
-                                    int tag = nw.Tag;
-                                    if (ipProperties.GatewayAddresses.Count > 0 && !nw.IsLoopback())
-                                    {
-                                        // -ve Tags signify the interface has a gateway.
-                                        nw.Tag *= -1;
-                                    }
-
-                                    _interfaceAddresses.AddItem(nw, false);
-
-                                    // Store interface name so we can use the name in Collections.
-                                    _interfaceNames[adapter.Description.ToLower(CultureInfo.InvariantCulture)] = tag;
-                                    _interfaceNames["eth" + tag.ToString(CultureInfo.InvariantCulture)] = tag;
-                                }
-                                else if (IsIP6Enabled && info.Address.AddressFamily == AddressFamily.InterNetworkV6)
-                                {
-                                    IPNetAddress nw = new IPNetAddress(info.Address, (byte)info.PrefixLength)
-                                    {
-                                        // Keep the number of gateways on this interface, along with its index.
-                                        Tag = ipProperties.GetIPv6Properties().Index
-                                    };
-
-                                    int tag = nw.Tag;
-                                    if (ipProperties.GatewayAddresses.Count > 0 && !nw.IsLoopback())
-                                    {
-                                        // -ve Tags signify the interface has a gateway.
-                                        nw.Tag *= -1;
-                                    }
-
-                                    _interfaceAddresses.AddItem(nw, false);
-
-                                    // Store interface name so we can use the name in Collections.
-                                    _interfaceNames[adapter.Description.ToLower(CultureInfo.InvariantCulture)] = tag;
-                                    _interfaceNames["eth" + tag.ToString(CultureInfo.InvariantCulture)] = tag;
-                                }
-                            }
-                        }
-#pragma warning disable CA1031 // Do not catch general exception types
-                        catch (Exception ex)
-                        {
-                            // Ignore error, and attempt to continue.
-                            _logger.LogError(ex, "Error encountered parsing interfaces.");
-                        }
-#pragma warning restore CA1031 // Do not catch general exception types
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error in InitialiseInterfaces.");
-                }
+        private IPData? FindInterfaceForIp(IPAddress address, bool localNetwork = false)
+        {
+            if (address == null)
+            {
+                throw new ArgumentNullException(nameof(address));
+            }
 
-                // If for some reason we don't have an interface info, resolve our DNS name.
-                if (_interfaceAddresses.Count == 0)
-                {
-                    _logger.LogError("No interfaces information available. Resolving DNS name.");
-                    IPHost host = new IPHost(Dns.GetHostName());
-                    foreach (var a in host.GetAddresses())
-                    {
-                        _interfaceAddresses.AddItem(a);
-                    }
+            var interfaces = _interfaces;
 
-                    if (_interfaceAddresses.Count == 0)
-                    {
-                        _logger.LogWarning("No interfaces information available. Using loopback.");
-                    }
-                }
+            if (localNetwork)
+            {
+                interfaces = interfaces.Where(x => IsInLocalNetwork(x.Address)).ToList();
+            }
 
-                if (IsIP4Enabled)
+            foreach (var intf in _interfaces)
+            {
+                if (intf.Subnet.Contains(address))
                 {
-                    _interfaceAddresses.AddItem(IPNetAddress.IP4Loopback);
+                    return intf;
                 }
+            }
 
-                if (IsIP6Enabled)
-                {
-                    _interfaceAddresses.AddItem(IPNetAddress.IP6Loopback);
-                }
+            return null;
+        }
 
-                _logger.LogDebug("Discovered {0} interfaces.", _interfaceAddresses.Count);
-                _logger.LogDebug("Interfaces addresses : {0}", _interfaceAddresses.AsString());
+        private bool CheckIfLanAndNotExcluded(IPAddress address)
+        {
+            bool match = false;
+            foreach (var lanSubnet in _lanSubnets)
+            {
+                match |= lanSubnet.Contains(address);
+            }
+
+            foreach (var excludedSubnet in _excludedSubnets)
+            {
+                match &= !excludedSubnet.Contains(address);
             }
+
+            NetworkExtensions.IsIPv6LinkLocal(address);
+            return match;
         }
 
         /// <summary>
-        /// Attempts to match the source against a user defined bind interface.
+        /// Attempts to match the source against the published server URL overrides.
         /// </summary>
         /// <param name="source">IP source address to use.</param>
-        /// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
-        /// <param name="bindPreference">The published server url that matches the source address.</param>
+        /// <param name="isInExternalSubnet">True if the source is in an external subnet.</param>
+        /// <param name="bindPreference">The published server URL that matches the source address.</param>
         /// <param name="port">The resultant port, if one exists.</param>
         /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
-        private bool MatchesPublishedServerUrl(IPObject source, bool isInExternalSubnet, out string bindPreference, out int? port)
+        private bool MatchesPublishedServerUrl(IPAddress source, bool isInExternalSubnet, out string bindPreference, out int? port)
         {
             bindPreference = string.Empty;
             port = null;
 
+            var validPublishedServerUrls = _publishedServerUrls.Where(x => x.Key.Address.Equals(IPAddress.Any)).ToList();
+            validPublishedServerUrls.AddRange(_publishedServerUrls.Where(x => x.Key.Address.Equals(IPAddress.IPv6Any)));
+            validPublishedServerUrls.AddRange(_publishedServerUrls.Where(x => x.Key.Subnet.Contains(source)));
+            validPublishedServerUrls.Distinct();
+
             // Check for user override.
-            foreach (var addr in _publishedServerUrls)
+            foreach (var data in validPublishedServerUrls)
             {
+                // Get address interface
+                var intf = _interfaces.FirstOrDefault(s => s.Subnet.Contains(data.Key.Address));
+
                 // Remaining. Match anything.
-                if (addr.Key.Address.Equals(IPAddress.Broadcast))
+                if (data.Key.Address.Equals(IPAddress.Broadcast))
                 {
-                    bindPreference = addr.Value;
+                    bindPreference = data.Value;
                     break;
                 }
-                else if ((addr.Key.Address.Equals(IPAddress.Any) || addr.Key.Address.Equals(IPAddress.IPv6Any)) && isInExternalSubnet)
+                else if ((data.Key.Address.Equals(IPAddress.Any) || data.Key.Address.Equals(IPAddress.IPv6Any)) && isInExternalSubnet)
                 {
                     // External.
-                    bindPreference = addr.Value;
+                    bindPreference = data.Value;
                     break;
                 }
-                else if (addr.Key.Contains(source))
+                else if (intf?.Address != null)
                 {
                     // Match ip address.
-                    bindPreference = addr.Value;
+                    bindPreference = data.Value;
                     break;
                 }
             }
@@ -1220,12 +1052,11 @@ namespace Jellyfin.Networking.Manager
         /// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
         /// <param name="result">The result, if a match is found.</param>
         /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
-        private bool MatchesBindInterface(IPObject source, bool isInExternalSubnet, out string result)
+        private bool MatchesBindInterface(IPAddress source, bool isInExternalSubnet, out string result)
         {
             result = string.Empty;
-            var addresses = _bindAddresses.Exclude(_bindExclusions, false);
 
-            int count = addresses.Count;
+            int count = _bindAddresses.Count;
             if (count == 1 && (_bindAddresses[0].Equals(IPAddress.Any) || _bindAddresses[0].Equals(IPAddress.IPv6Any)))
             {
                 // Ignore IPAny addresses.
@@ -1234,24 +1065,25 @@ namespace Jellyfin.Networking.Manager
 
             if (count != 0)
             {
-                // Check to see if any of the bind interfaces are in the same subnet.
-
+                // Check to see if any of the bind interfaces are in the same subnet as the source.
                 IPAddress? defaultGateway = null;
                 IPAddress? bindAddress = null;
 
                 if (isInExternalSubnet)
                 {
                     // Find all external bind addresses. Store the default gateway, but check to see if there is a better match first.
-                    foreach (var addr in addresses.OrderBy(p => p.Tag))
+                    foreach (var addr in _bindAddresses)
                     {
                         if (defaultGateway == null && !IsInLocalNetwork(addr))
                         {
-                            defaultGateway = addr.Address;
+                            defaultGateway = addr;
                         }
 
-                        if (bindAddress == null && addr.Contains(source))
+                        var intf = _interfaces.Where(x => x.Subnet.Contains(addr)).FirstOrDefault();
+
+                        if (bindAddress == null && intf != null && intf.Subnet.Contains(source))
                         {
-                            bindAddress = addr.Address;
+                            bindAddress = intf.Address;
                         }
 
                         if (defaultGateway != null && bindAddress != null)
@@ -1263,32 +1095,37 @@ namespace Jellyfin.Networking.Manager
                 else
                 {
                     // Look for the best internal address.
-                    bindAddress = addresses
-                        .Where(p => IsInLocalNetwork(p) && (p.Contains(source) || p.Equals(IPAddress.None)))
-                        .OrderBy(p => p.Tag)
-                        .FirstOrDefault()?.Address;
+                    foreach (var bA in _bindAddresses.Where(x => IsInLocalNetwork(x)))
+                    {
+                        var intf = FindInterfaceForIp(source, true);
+                        if (intf != null)
+                        {
+                            bindAddress = intf.Address;
+                            break;
+                        }
+                    }
                 }
 
                 if (bindAddress != null)
                 {
-                    result = FormatIP6String(bindAddress);
-                    _logger.LogDebug("{Source}: GetBindInterface: Has source, found a match bind interface subnets. {Result}", source, result);
+                    result = NetworkExtensions.FormatIpString(bindAddress);
+                    _logger.LogDebug("{Source}: GetBindInterface: Has source, found a matching bind interface subnet. {Result}", source, result);
                     return true;
                 }
 
                 if (isInExternalSubnet && defaultGateway != null)
                 {
-                    result = FormatIP6String(defaultGateway);
+                    result = NetworkExtensions.FormatIpString(defaultGateway);
                     _logger.LogDebug("{Source}: GetBindInterface: Using first user defined external interface. {Result}", source, result);
                     return true;
                 }
 
-                result = FormatIP6String(addresses[0].Address);
+                result = NetworkExtensions.FormatIpString(_bindAddresses[0]);
                 _logger.LogDebug("{Source}: GetBindInterface: Selected first user defined interface. {Result}", source, result);
 
                 if (isInExternalSubnet)
                 {
-                    _logger.LogWarning("{Source}: External request received, however, only an internal interface bind found.", source);
+                    _logger.LogWarning("{Source}: External request received, only an internal interface bind found.", source);
                 }
 
                 return true;
@@ -1303,30 +1140,29 @@ namespace Jellyfin.Networking.Manager
         /// <param name="source">IP source address to use.</param>
         /// <param name="result">The result, if a match is found.</param>
         /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
-        private bool MatchesExternalInterface(IPObject source, out string result)
+        private bool MatchesExternalInterface(IPAddress source, out string result)
         {
             result = string.Empty;
             // Get the first WAN interface address that isn't a loopback.
-            var extResult = _interfaceAddresses
-                .Exclude(_bindExclusions, false)
-                .Where(p => !IsInLocalNetwork(p))
-                .OrderBy(p => p.Tag);
+            var extResult = _interfaces.Where(p => !IsInLocalNetwork(p.Address));
 
-            if (extResult.Any())
+            IPAddress? hasResult = null;
+            // Does the request originate in one of the interface subnets?
+            // (For systems with multiple internal network cards, and multiple subnets)
+            foreach (var intf in extResult)
             {
-                // Does the request originate in one of the interface subnets?
-                // (For systems with multiple internal network cards, and multiple subnets)
-                foreach (var intf in extResult)
+                hasResult ??= intf.Address;
+                if (!IsInLocalNetwork(intf.Address) && intf.Subnet.Contains(source))
                 {
-                    if (!IsInLocalNetwork(intf) && intf.Contains(source))
-                    {
-                        result = FormatIP6String(intf.Address);
-                        _logger.LogDebug("{Source}: GetBindInterface: Selected best external on interface on range. {Result}", source, result);
-                        return true;
-                    }
+                    result = NetworkExtensions.FormatIpString(intf.Address);
+                    _logger.LogDebug("{Source}: GetBindInterface: Selected best external on interface on range. {Result}", source, result);
+                    return true;
                 }
+            }
 
-                result = FormatIP6String(extResult.First().Address);
+            if (hasResult != null)
+            {
+                result = NetworkExtensions.FormatIpString(hasResult);
                 _logger.LogDebug("{Source}: GetBindInterface: Selected first external interface. {Result}", source, result);
                 return true;
             }
diff --git a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
index 66fa3bc31..7030b726c 100644
--- a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
+++ b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
@@ -344,13 +344,13 @@ namespace Jellyfin.Server.Extensions
         {
             for (var i = 0; i < allowedProxies.Length; i++)
             {
-                if (IPNetAddress.TryParse(allowedProxies[i], out var addr))
+                if (IPAddress.TryParse(allowedProxies[i], out var addr))
                 {
-                    AddIpAddress(config, options, addr.Address, addr.PrefixLength);
+                    AddIpAddress(config, options, addr, addr.AddressFamily == AddressFamily.InterNetwork ? 32 : 128);
                 }
-                else if (IPHost.TryParse(allowedProxies[i], out var host))
+                else if (NetworkExtensions.TryParseHost(allowedProxies[i], out var host))
                 {
-                    foreach (var address in host.GetAddresses())
+                    foreach (var address in host)
                     {
                         AddIpAddress(config, options, address, address.AddressFamily == AddressFamily.InterNetwork ? 32 : 128);
                     }
diff --git a/Jellyfin.Server/Migrations/PreStartupRoutines/CreateNetworkConfiguration.cs b/Jellyfin.Server/Migrations/PreStartupRoutines/CreateNetworkConfiguration.cs
index 5e601ca84..ceeaa26e6 100644
--- a/Jellyfin.Server/Migrations/PreStartupRoutines/CreateNetworkConfiguration.cs
+++ b/Jellyfin.Server/Migrations/PreStartupRoutines/CreateNetworkConfiguration.cs
@@ -114,9 +114,7 @@ public class CreateNetworkConfiguration : IMigrationRoutine
 
         public bool IgnoreVirtualInterfaces { get; set; } = true;
 
-        public string VirtualInterfaceNames { get; set; } = "vEthernet*";
-
-        public bool TrustAllIP6Interfaces { get; set; }
+        public string VirtualInterfaceNames { get; set; } = "veth*";
 
         public string[] PublishedServerUriBySubnet { get; set; } = Array.Empty<string>();
 
diff --git a/Jellyfin.Server/Program.cs b/Jellyfin.Server/Program.cs
index 2bda8d290..63055a61d 100644
--- a/Jellyfin.Server/Program.cs
+++ b/Jellyfin.Server/Program.cs
@@ -300,7 +300,7 @@ namespace Jellyfin.Server
                     var addresses = appHost.NetManager.GetAllBindInterfaces();
 
                     bool flagged = false;
-                    foreach (IPObject netAdd in addresses)
+                    foreach (IPData netAdd in addresses)
                     {
                         _logger.LogInformation("Kestrel listening on {Address}", netAdd.Address == IPAddress.IPv6Any ? "All Addresses" : netAdd);
                         options.Listen(netAdd.Address, appHost.HttpPort);
@@ -689,10 +689,10 @@ namespace Jellyfin.Server
 
             if (!string.IsNullOrEmpty(socketPerms))
             {
-                #pragma warning disable SA1300 // Entrypoint is case sensitive.
+#pragma warning disable SA1300 // Entrypoint is case sensitive.
                 [DllImport("libc")]
                 static extern int chmod(string pathname, int mode);
-                #pragma warning restore SA1300
+#pragma warning restore SA1300
 
                 var exitCode = chmod(socketPath, Convert.ToInt32(socketPerms, 8));
 
diff --git a/MediaBrowser.Common/Net/INetworkManager.cs b/MediaBrowser.Common/Net/INetworkManager.cs
index b93939730..fdf42bdbc 100644
--- a/MediaBrowser.Common/Net/INetworkManager.cs
+++ b/MediaBrowser.Common/Net/INetworkManager.cs
@@ -18,44 +18,29 @@ namespace MediaBrowser.Common.Net
         event EventHandler NetworkChanged;
 
         /// <summary>
-        /// Gets the published server urls list.
+        /// Gets a value indicating whether iP6 is enabled.
         /// </summary>
-        Dictionary<IPNetAddress, string> PublishedServerUrls { get; }
+        bool IsIpv6Enabled { get; }
 
         /// <summary>
-        /// Gets a value indicating whether is all IPv6 interfaces are trusted as internal.
+        /// Gets a value indicating whether iP4 is enabled.
         /// </summary>
-        bool TrustAllIP6Interfaces { get; }
-
-        /// <summary>
-        /// Gets the remote address filter.
-        /// </summary>
-        Collection<IPObject> RemoteAddressFilter { get; }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether iP6 is enabled.
-        /// </summary>
-        bool IsIP6Enabled { get; set; }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether iP4 is enabled.
-        /// </summary>
-        bool IsIP4Enabled { get; set; }
+        bool IsIpv4Enabled { get; }
 
         /// <summary>
         /// Calculates the list of interfaces to use for Kestrel.
         /// </summary>
-        /// <returns>A Collection{IPObject} object containing all the interfaces to bind.
+        /// <returns>A List{IPData} object containing all the interfaces to bind.
         /// If all the interfaces are specified, and none are excluded, it returns zero items
         /// to represent any address.</returns>
         /// <param name="individualInterfaces">When false, return <see cref="IPAddress.Any"/> or <see cref="IPAddress.IPv6Any"/> for all interfaces.</param>
-        Collection<IPObject> GetAllBindInterfaces(bool individualInterfaces = false);
+        List<IPData> GetAllBindInterfaces(bool individualInterfaces = false);
 
         /// <summary>
         /// Returns a collection containing the loopback interfaces.
         /// </summary>
-        /// <returns>Collection{IPObject}.</returns>
-        Collection<IPObject> GetLoopbacks();
+        /// <returns>List{IPData}.</returns>
+        List<IPData> GetLoopbacks();
 
         /// <summary>
         /// Retrieves the bind address to use in system url's. (Server Discovery, PlayTo, LiveTV, SystemInfo)
@@ -86,22 +71,12 @@ namespace MediaBrowser.Common.Net
         /// <param name="source">Source of the request.</param>
         /// <param name="port">Optional port returned, if it's part of an override.</param>
         /// <returns>IP Address to use, or loopback address if all else fails.</returns>
-        string GetBindInterface(IPObject source, out int? port);
-
-        /// <summary>
-        /// Retrieves the bind address to use in system url's. (Server Discovery, PlayTo, LiveTV, SystemInfo)
-        /// If no bind addresses are specified, an internal interface address is selected.
-        /// (See <see cref="GetBindInterface(IPObject, out int?)"/>.
-        /// </summary>
-        /// <param name="source">Source of the request.</param>
-        /// <param name="port">Optional port returned, if it's part of an override.</param>
-        /// <returns>IP Address to use, or loopback address if all else fails.</returns>
         string GetBindInterface(HttpRequest source, out int? port);
 
         /// <summary>
         /// Retrieves the bind address to use in system url's. (Server Discovery, PlayTo, LiveTV, SystemInfo)
         /// If no bind addresses are specified, an internal interface address is selected.
-        /// (See <see cref="GetBindInterface(IPObject, out int?)"/>.
+        /// (See <see cref="GetBindInterface(IPAddress, out int?)"/>.
         /// </summary>
         /// <param name="source">IP address of the request.</param>
         /// <param name="port">Optional port returned, if it's part of an override.</param>
@@ -111,7 +86,7 @@ namespace MediaBrowser.Common.Net
         /// <summary>
         /// Retrieves the bind address to use in system url's. (Server Discovery, PlayTo, LiveTV, SystemInfo)
         /// If no bind addresses are specified, an internal interface address is selected.
-        /// (See <see cref="GetBindInterface(IPObject, out int?)"/>.
+        /// (See <see cref="GetBindInterface(IPAddress, out int?)"/>.
         /// </summary>
         /// <param name="source">Source of the request.</param>
         /// <param name="port">Optional port returned, if it's part of an override.</param>
@@ -119,41 +94,12 @@ namespace MediaBrowser.Common.Net
         string GetBindInterface(string source, out int? port);
 
         /// <summary>
-        /// Checks to see if the ip address is specifically excluded in LocalNetworkAddresses.
-        /// </summary>
-        /// <param name="address">IP address to check.</param>
-        /// <returns>True if it is.</returns>
-        bool IsExcludedInterface(IPAddress address);
-
-        /// <summary>
         /// Get a list of all the MAC addresses associated with active interfaces.
         /// </summary>
         /// <returns>List of MAC addresses.</returns>
         IReadOnlyCollection<PhysicalAddress> GetMacAddresses();
 
         /// <summary>
-        /// Checks to see if the IP Address provided matches an interface that has a gateway.
-        /// </summary>
-        /// <param name="addressObj">IP to check. Can be an IPAddress or an IPObject.</param>
-        /// <returns>Result of the check.</returns>
-        bool IsGatewayInterface(IPObject? addressObj);
-
-        /// <summary>
-        /// Checks to see if the IP Address provided matches an interface that has a gateway.
-        /// </summary>
-        /// <param name="addressObj">IP to check. Can be an IPAddress or an IPObject.</param>
-        /// <returns>Result of the check.</returns>
-        bool IsGatewayInterface(IPAddress? addressObj);
-
-        /// <summary>
-        /// Returns true if the address is a private address.
-        /// The configuration option TrustIP6Interfaces overrides this functions behaviour.
-        /// </summary>
-        /// <param name="address">Address to check.</param>
-        /// <returns>True or False.</returns>
-        bool IsPrivateAddressRange(IPObject address);
-
-        /// <summary>
         /// Returns true if the address is part of the user defined LAN.
         /// The configuration option TrustIP6Interfaces overrides this functions behaviour.
         /// </summary>
@@ -167,66 +113,22 @@ namespace MediaBrowser.Common.Net
         /// </summary>
         /// <param name="address">IP to check.</param>
         /// <returns>True if endpoint is within the LAN range.</returns>
-        bool IsInLocalNetwork(IPObject address);
-
-        /// <summary>
-        /// Returns true if the address is part of the user defined LAN.
-        /// The configuration option TrustIP6Interfaces overrides this functions behaviour.
-        /// </summary>
-        /// <param name="address">IP to check.</param>
-        /// <returns>True if endpoint is within the LAN range.</returns>
         bool IsInLocalNetwork(IPAddress address);
 
         /// <summary>
-        /// Attempts to convert the token to an IP address, permitting for interface descriptions and indexes.
-        /// eg. "eth1", or "TP-LINK Wireless USB Adapter".
+        /// Attempts to convert the interface name to an IP address.
+        /// eg. "eth1", or "enp3s5".
         /// </summary>
-        /// <param name="token">Token to parse.</param>
+        /// <param name="intf">Interface name.</param>
         /// <param name="result">Resultant object's ip addresses, if successful.</param>
         /// <returns>Success of the operation.</returns>
-        bool TryParseInterface(string token, out Collection<IPObject>? result);
-
-        /// <summary>
-        /// Parses an array of strings into a Collection{IPObject}.
-        /// </summary>
-        /// <param name="values">Values to parse.</param>
-        /// <param name="negated">When true, only include values beginning with !. When false, ignore ! values.</param>
-        /// <returns>IPCollection object containing the value strings.</returns>
-        Collection<IPObject> CreateIPCollection(string[] values, bool negated = false);
+        bool TryParseInterface(string intf, out Collection<IPData>? result);
 
         /// <summary>
         /// Returns all the internal Bind interface addresses.
         /// </summary>
         /// <returns>An internal list of interfaces addresses.</returns>
-        Collection<IPObject> GetInternalBindAddresses();
-
-        /// <summary>
-        /// Checks to see if an IP address is still a valid interface address.
-        /// </summary>
-        /// <param name="address">IP address to check.</param>
-        /// <returns>True if it is.</returns>
-        bool IsValidInterfaceAddress(IPAddress address);
-
-        /// <summary>
-        /// Returns true if the IP address is in the excluded list.
-        /// </summary>
-        /// <param name="ip">IP to check.</param>
-        /// <returns>True if excluded.</returns>
-        bool IsExcluded(IPAddress ip);
-
-        /// <summary>
-        /// Returns true if the IP address is in the excluded list.
-        /// </summary>
-        /// <param name="ip">IP to check.</param>
-        /// <returns>True if excluded.</returns>
-        bool IsExcluded(EndPoint ip);
-
-        /// <summary>
-        /// Gets the filtered LAN ip addresses.
-        /// </summary>
-        /// <param name="filter">Optional filter for the list.</param>
-        /// <returns>Returns a filtered list of LAN addresses.</returns>
-        Collection<IPObject> GetFilteredLANSubnets(Collection<IPObject>? filter = null);
+        List<IPData> GetInternalBindAddresses();
 
         /// <summary>
         /// Checks to see if <paramref name="remoteIp"/> has access.
diff --git a/MediaBrowser.Common/Net/IPData.cs b/MediaBrowser.Common/Net/IPData.cs
new file mode 100644
index 000000000..3c6adc7e8
--- /dev/null
+++ b/MediaBrowser.Common/Net/IPData.cs
@@ -0,0 +1,76 @@
+using System.Net;
+using System.Net.Sockets;
+using Microsoft.AspNetCore.HttpOverrides;
+
+namespace MediaBrowser.Common.Net
+{
+    /// <summary>
+    /// Base network object class.
+    /// </summary>
+    public class IPData
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPData"/> class.
+        /// </summary>
+        /// <param name="address">An <see cref="IPAddress"/>.</param>
+        /// <param name="subnet">The <see cref="IPNetwork"/>.</param>
+        public IPData(
+            IPAddress address,
+            IPNetwork? subnet)
+        {
+            Address = address;
+            Subnet = subnet ?? (address.AddressFamily == AddressFamily.InterNetwork ? new IPNetwork(address, 32) : new IPNetwork(address, 128));
+            Name = string.Empty;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IPData"/> class.
+        /// </summary>
+        /// <param name="address">An <see cref="IPAddress"/>.</param>
+        /// <param name="subnet">The <see cref="IPNetwork"/>.</param>
+        /// <param name="name">The object's name.</param>
+        public IPData(
+            IPAddress address,
+            IPNetwork? subnet,
+            string name)
+        {
+            Address = address;
+            Subnet = subnet ?? (address.AddressFamily == AddressFamily.InterNetwork ? new IPNetwork(address, 32) : new IPNetwork(address, 128));
+            Name = name;
+        }
+
+        /// <summary>
+        /// Gets or sets the object's IP address.
+        /// </summary>
+        public IPAddress Address { get; set; }
+
+        /// <summary>
+        /// Gets or sets the object's IP address.
+        /// </summary>
+        public IPNetwork Subnet { get; set; }
+
+        /// <summary>
+        /// Gets or sets the interface index.
+        /// </summary>
+        public int Index { get; set; }
+
+        /// <summary>
+        /// Gets or sets the interface name.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets the AddressFamily of this object.
+        /// </summary>
+        public AddressFamily AddressFamily
+        {
+            get
+            {
+                return Address.Equals(IPAddress.None)
+                    ? (Subnet.Prefix.AddressFamily.Equals(IPAddress.None)
+                        ? AddressFamily.Unspecified : Subnet.Prefix.AddressFamily)
+                    : Address.AddressFamily;
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Common/Net/IPHost.cs b/MediaBrowser.Common/Net/IPHost.cs
deleted file mode 100644
index 1f125f2b1..000000000
--- a/MediaBrowser.Common/Net/IPHost.cs
+++ /dev/null
@@ -1,441 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Linq;
-using System.Net;
-using System.Net.Sockets;
-using System.Text.RegularExpressions;
-
-namespace MediaBrowser.Common.Net
-{
-    /// <summary>
-    /// Object that holds a host name.
-    /// </summary>
-    public class IPHost : IPObject
-    {
-        /// <summary>
-        /// Gets or sets timeout value before resolve required, in minutes.
-        /// </summary>
-        public const int Timeout = 30;
-
-        /// <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 in ticks.
-        /// </summary>
-        private DateTime? _lastResolved = null;
-
-        /// <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, as a host's address is determined by DNS.
-                throw new NotImplementedException("The address of a host is determined by DNS.");
-            }
-        }
-
-        /// <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 => (byte)(ResolveHost() ? 128 : 32);
-
-            // Not implemented, as a host object can only have a prefix length of 128 (IPv6) or 32 (IPv4) prefix length,
-            // which is automatically determined by it's IP type. Anything else is meaningless.
-            set => throw new NotImplementedException();
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the address has a value.
-        /// </summary>
-        public bool HasAddress => _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><c>true</c> if the parsing is successful, <c>false</c> if not.</returns>
-        public static bool TryParse(string host, out IPHost hostObj)
-        {
-            if (string.IsNullOrWhiteSpace(host))
-            {
-                hostObj = IPHost.None;
-                return false;
-            }
-
-            // See if it's an IPv6 with port address e.g. [::1] or [::1]:120.
-            int i = host.IndexOf(']', StringComparison.Ordinal);
-            if (i != -1)
-            {
-                return TryParse(host.Remove(i - 1).TrimStart(' ', '['), out hostObj);
-            }
-
-            if (IPNetAddress.TryParse(host, out var netAddress))
-            {
-                // Host name is an ip address, so fake resolve.
-                hostObj = new IPHost(host, netAddress.Address);
-                return true;
-            }
-
-            // Is it a host, IPv4/6 with/out port?
-            string[] hosts = host.Split(':');
-
-            if (hosts.Length <= 2)
-            {
-                // This is either a hostname: port, or an IP4:port.
-                host = hosts[0];
-
-                if (string.Equals("localhost", host, StringComparison.OrdinalIgnoreCase))
-                {
-                    hostObj = new IPHost(host);
-                    return true;
-                }
-
-                if (IPAddress.TryParse(host, out var netIP))
-                {
-                    // Host name is an ip address, so fake resolve.
-                    hostObj = new IPHost(host, netIP);
-                    return true;
-                }
-            }
-            else
-            {
-                // Invalid host name, as it cannot contain :
-                hostObj = new IPHost(string.Empty, IPAddress.None);
-                return 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-]+\.?)$";
-
-            if (Regex.IsMatch(host, pattern))
-            {
-                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 if (i.AddressFamily == AddressFamily.InterNetwork)
-                    {
-                        output += $"{i}/32,";
-                    }
-                    else
-                    {
-                        output += $"{i}/128,";
-                    }
-                }
-
-                output = output[..^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 (address, prefixLength) = NetworkAddressOf(this[0], PrefixLength);
-            return new IPNetAddress(address, prefixLength);
-        }
-
-        /// <summary>
-        /// Attempt to resolve the ip address of a host.
-        /// </summary>
-        /// <returns><c>true</c> if any addresses have been resolved, otherwise <c>false</c>.</returns>
-        private bool ResolveHost()
-        {
-            // When was the last time we resolved?
-            _lastResolved ??= DateTime.UtcNow;
-
-            // If we haven't resolved before, or our timer has run out...
-            if ((_addresses.Length == 0 && !Resolved) || (DateTime.UtcNow > _lastResolved.Value.AddMinutes(Timeout)))
-            {
-                _lastResolved = DateTime.UtcNow;
-                ResolveHostInternal();
-                Resolved = true;
-            }
-
-            return _addresses.Length > 0;
-        }
-
-        /// <summary>
-        /// Task that looks up a Host name and returns its IP addresses.
-        /// </summary>
-        private void ResolveHostInternal()
-        {
-            var hostName = HostName;
-            if (string.IsNullOrEmpty(hostName))
-            {
-                return;
-            }
-
-            // Resolves the host name - so save a DNS lookup.
-            if (string.Equals(hostName, "localhost", StringComparison.OrdinalIgnoreCase))
-            {
-                _addresses = new IPAddress[] { IPAddress.Loopback, IPAddress.IPv6Loopback };
-                return;
-            }
-
-            if (Uri.CheckHostName(hostName) == UriHostNameType.Dns)
-            {
-                try
-                {
-                    _addresses = Dns.GetHostEntry(hostName).AddressList;
-                }
-                catch (SocketException ex)
-                {
-                    // Log and then ignore socket errors, as the result value will just be an empty array.
-                    Debug.WriteLine("GetHostAddresses failed with {Message}.", ex.Message);
-                }
-            }
-        }
-    }
-}
diff --git a/MediaBrowser.Common/Net/IPNetAddress.cs b/MediaBrowser.Common/Net/IPNetAddress.cs
deleted file mode 100644
index f1428d4be..000000000
--- a/MediaBrowser.Common/Net/IPNetAddress.cs
+++ /dev/null
@@ -1,276 +0,0 @@
-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 SSDPMulticastIPv4 = IPAddress.Parse("239.255.255.250");
-
-        /// <summary>
-        /// IPv6 local link multicast address.
-        /// </summary>
-        public static readonly IPAddress SSDPMulticastIPv6LinkLocal = IPAddress.Parse("ff02::C");
-
-        /// <summary>
-        /// IPv6 site local multicast address.
-        /// </summary>
-        public static readonly IPAddress SSDPMulticastIPv6SiteLocal = IPAddress.Parse("ff05::C");
-
-        /// <summary>
-        /// IP4Loopback address host.
-        /// </summary>
-        public static readonly IPNetAddress IP4Loopback = IPNetAddress.Parse("127.0.0.1/8");
-
-        /// <summary>
-        /// IP6Loopback address host.
-        /// </summary>
-        public static readonly IPNetAddress IP6Loopback = new IPNetAddress(IPAddress.IPv6Loopback);
-
-        /// <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, altPrefix) = NetworkAddressOf(address, PrefixLength);
-            return NetworkAddress.Address.Equals(altAddress) && NetworkAddress.PrefixLength >= altPrefix;
-        }
-
-        /// <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).Address;
-                return NetworkAddress.Address.Equals(altAddress);
-            }
-
-            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 ip)
-        {
-            if (ip != null && !ip.Equals(IPAddress.None) && !Address.Equals(IPAddress.None))
-            {
-                return ip.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 excluded 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 (address, prefixLength) = NetworkAddressOf(_address, PrefixLength);
-            return new IPNetAddress(address, prefixLength);
-        }
-    }
-}
diff --git a/MediaBrowser.Common/Net/IPObject.cs b/MediaBrowser.Common/Net/IPObject.cs
deleted file mode 100644
index 3a5187bc3..000000000
--- a/MediaBrowser.Common/Net/IPObject.cs
+++ /dev/null
@@ -1,370 +0,0 @@
-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>
-        /// The network address of this object.
-        /// </summary>
-        private IPObject? _networkAddress;
-
-        /// <summary>
-        /// Gets or sets a user defined value that is associated with 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 => _networkAddress ??= CalculateNetworkAddress();
-
-        /// <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 (IPAddress.IsLoopback(address))
-            {
-                return (address, prefixLength);
-            }
-
-            // An ip address is just a list of bytes, each one representing a segment on the network.
-            // This separates the IP address into octets and calculates how many octets will need to be altered or set to zero dependant upon the
-            // prefix length value. eg. /16 on a 4 octet ip4 address (192.168.2.240) will result in the 2 and the 240 being zeroed out.
-            // Where there is not an exact boundary (eg /23), mod is used to calculate how many bits of this value are to be kept.
-
-            // GetAddressBytes
-            Span<byte> addressBytes = stackalloc byte[address.AddressFamily == AddressFamily.InterNetwork ? 4 : 16];
-            address.TryWriteBytes(addressBytes, out _);
-
-            int div = prefixLength / 8;
-            int mod = prefixLength % 8;
-            if (mod != 0)
-            {
-                // Prefix length is counted right to left, so subtract 8 so we know how many bits to clear.
-                mod = 8 - mod;
-
-                // Shift out the bits from the octet that we don't want, by moving right then back left.
-                addressBytes[div] = (byte)((int)addressBytes[div] >> mod << mod);
-                // Move on the next byte.
-                div++;
-            }
-
-            // Blank out the remaining octets from mod + 1 to the end of the byte array. (192.168.2.240/16 becomes 192.168.0.0)
-            for (int octet = div; octet < addressBytes.Length; octet++)
-            {
-                addressBytes[octet] = 0;
-            }
-
-            // Return the network address for the prefix.
-            return (new IPAddress(addressBytes), prefixLength);
-        }
-
-        /// <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.IsIPv4MappedToIPv6)
-                {
-                    address = address.MapToIPv4();
-                }
-
-                if (address.AddressFamily == AddressFamily.InterNetwork)
-                {
-                    // GetAddressBytes
-                    Span<byte> octet = stackalloc byte[4];
-                    address.TryWriteBytes(octet, out _);
-
-                    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
-                {
-                    // GetAddressBytes
-                    Span<byte> octet = stackalloc byte[16];
-                    address.TryWriteBytes(octet, out _);
-
-                    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;
-            }
-
-            // GetAddressBytes
-            Span<byte> octet = stackalloc byte[16];
-            address.TryWriteBytes(octet, out _);
-            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))
-            {
-                // GetAddressBytes
-                Span<byte> bytes = stackalloc byte[mask.AddressFamily == AddressFamily.InterNetwork ? 4 : 16];
-                mask.TryWriteBytes(bytes, out _);
-
-                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 IPAddress.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 performs 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)
-            {
-                return !Address.Equals(IPAddress.None) && Address.Equals(other.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
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;
         }
     }
 }
diff --git a/MediaBrowser.Controller/IServerApplicationHost.cs b/MediaBrowser.Controller/IServerApplicationHost.cs
index 11afdc4ae..45ac5c3a8 100644
--- a/MediaBrowser.Controller/IServerApplicationHost.cs
+++ b/MediaBrowser.Controller/IServerApplicationHost.cs
@@ -4,7 +4,6 @@
 
 using System.Net;
 using MediaBrowser.Common;
-using MediaBrowser.Common.Net;
 using MediaBrowser.Model.System;
 using Microsoft.AspNetCore.Http;
 
@@ -75,10 +74,10 @@ namespace MediaBrowser.Controller
         /// <summary>
         /// Gets an URL that can be used to access the API over LAN.
         /// </summary>
-        /// <param name="hostname">An optional hostname to use.</param>
+        /// <param name="ipAddress">An optional IP address to use.</param>
         /// <param name="allowHttps">A value indicating whether to allow HTTPS.</param>
         /// <returns>The API URL.</returns>
-        string GetApiUrlForLocalAccess(IPObject hostname = null, bool allowHttps = true);
+        string GetApiUrlForLocalAccess(IPAddress ipAddress = null, bool allowHttps = true);
 
         /// <summary>
         /// Gets a local (LAN) URL that can be used to access the API.
diff --git a/RSSDP/SsdpDevicePublisher.cs b/RSSDP/SsdpDevicePublisher.cs
index a7767b3c0..37c4128ba 100644
--- a/RSSDP/SsdpDevicePublisher.cs
+++ b/RSSDP/SsdpDevicePublisher.cs
@@ -7,6 +7,7 @@ using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Common.Net;
+using Microsoft.AspNetCore.HttpOverrides;
 
 namespace Rssdp.Infrastructure
 {
@@ -297,9 +298,9 @@ namespace Rssdp.Infrastructure
                     foreach (var device in deviceList)
                     {
                         var root = device.ToRootDevice();
-                        var source = new IPNetAddress(root.Address, root.PrefixLength);
-                        var destination = new IPNetAddress(remoteEndPoint.Address, root.PrefixLength);
-                        if (!_sendOnlyMatchedHost || source.NetworkAddress.Equals(destination.NetworkAddress))
+                        var source = new IPData(root.Address, new IPNetwork(root.Address, root.PrefixLength), root.FriendlyName);
+                        var destination = new IPData(remoteEndPoint.Address, new IPNetwork(root.Address, root.PrefixLength));
+                        if (!_sendOnlyMatchedHost || source.Address.Equals(destination.Address))
                         {
                             SendDeviceSearchResponses(device, remoteEndPoint, receivedOnlocalIpAddress, cancellationToken);
                         }
diff --git a/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs b/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs
deleted file mode 100644
index aa2dbc57a..000000000
--- a/tests/Jellyfin.Networking.Tests/IPNetAddressTests.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using FsCheck;
-using FsCheck.Xunit;
-using MediaBrowser.Common.Net;
-using Xunit;
-
-namespace Jellyfin.Networking.Tests
-{
-    public static class IPNetAddressTests
-    {
-        /// <summary>
-        /// Checks IP address formats.
-        /// </summary>
-        /// <param name="address">IP Address.</param>
-        [Theory]
-        [InlineData("127.0.0.1")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517/56")]
-        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517]")]
-        [InlineData("fe80::7add:12ff:febb:c67b%16")]
-        [InlineData("[fe80::7add:12ff:febb:c67b%16]:123")]
-        [InlineData("fe80::7add:12ff:febb:c67b%16:123")]
-        [InlineData("[fe80::7add:12ff:febb:c67b%16]")]
-        [InlineData("192.168.1.2/255.255.255.0")]
-        [InlineData("192.168.1.2/24")]
-        public static void TryParse_ValidIPStrings_True(string address)
-            => Assert.True(IPNetAddress.TryParse(address, out _));
-
-        [Property]
-        public static Property TryParse_IPv4Address_True(IPv4Address address)
-            => IPNetAddress.TryParse(address.Item.ToString(), out _).ToProperty();
-
-        [Property]
-        public static Property TryParse_IPv6Address_True(IPv6Address address)
-            => IPNetAddress.TryParse(address.Item.ToString(), out _).ToProperty();
-
-        /// <summary>
-        /// All should be invalid address strings.
-        /// </summary>
-        /// <param name="address">Invalid address strings.</param>
-        [Theory]
-        [InlineData("256.128.0.0.0.1")]
-        [InlineData("127.0.0.1#")]
-        [InlineData("localhost!")]
-        [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517:1231")]
-        [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517:1231]")]
-        public static void TryParse_InvalidAddressString_False(string address)
-            => Assert.False(IPNetAddress.TryParse(address, out _));
-    }
-}
diff --git a/tests/Jellyfin.Networking.Tests/IPHostTests.cs b/tests/Jellyfin.Networking.Tests/NetworkExtensionsTests.cs
index ec3a1300c..c81fdefe9 100644
--- a/tests/Jellyfin.Networking.Tests/IPHostTests.cs
+++ b/tests/Jellyfin.Networking.Tests/NetworkExtensionsTests.cs
@@ -5,7 +5,7 @@ using Xunit;
 
 namespace Jellyfin.Networking.Tests
 {
-    public static class IPHostTests
+    public static class NetworkExtensionsTests
     {
         /// <summary>
         /// Checks IP address formats.
@@ -27,15 +27,15 @@ namespace Jellyfin.Networking.Tests
         [InlineData("192.168.1.2/255.255.255.0")]
         [InlineData("192.168.1.2/24")]
         public static void TryParse_ValidHostStrings_True(string address)
-            => Assert.True(IPHost.TryParse(address, out _));
+            => Assert.True(NetworkExtensions.TryParseHost(address, out _, true, true));
 
         [Property]
         public static Property TryParse_IPv4Address_True(IPv4Address address)
-            => IPHost.TryParse(address.Item.ToString(), out _).ToProperty();
+            => NetworkExtensions.TryParseHost(address.Item.ToString(), out _, true, true).ToProperty();
 
         [Property]
         public static Property TryParse_IPv6Address_True(IPv6Address address)
-            => IPHost.TryParse(address.Item.ToString(), out _).ToProperty();
+            => NetworkExtensions.TryParseHost(address.Item.ToString(), out _, true, true).ToProperty();
 
         /// <summary>
         /// All should be invalid address strings.
@@ -48,6 +48,6 @@ namespace Jellyfin.Networking.Tests
         [InlineData("fd23:184f:2029:0:3139:7386:67d7:d517:1231")]
         [InlineData("[fd23:184f:2029:0:3139:7386:67d7:d517:1231]")]
         public static void TryParse_InvalidAddressString_False(string address)
-            => Assert.False(IPHost.TryParse(address, out _));
+            => Assert.False(NetworkExtensions.TryParseHost(address, out _, true, true));
     }
 }
diff --git a/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
index 6b9397437..ce638c913 100644
--- a/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
+++ b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
@@ -1,10 +1,13 @@
 using System;
 using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
 using System.Net;
 using Jellyfin.Networking.Configuration;
 using Jellyfin.Networking.Manager;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Net;
+using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
@@ -46,6 +49,8 @@ namespace Jellyfin.Networking.Tests
             {
                 EnableIPV6 = true,
                 EnableIPV4 = true,
+                IgnoreVirtualInterfaces = true,
+                VirtualInterfaceNames = "veth",
                 LocalNetworkSubnets = lan?.Split(';') ?? throw new ArgumentNullException(nameof(lan))
             };
 
@@ -53,135 +58,7 @@ namespace Jellyfin.Networking.Tests
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
             NetworkManager.MockNetworkSettings = string.Empty;
 
-            Assert.Equal(nm.GetInternalBindAddresses().AsString(), value);
-        }
-
-        /// <summary>
-        /// Test collection parsing.
-        /// </summary>
-        /// <param name="settings">Collection to parse.</param>
-        /// <param name="result1">Included addresses from the collection.</param>
-        /// <param name="result2">Included IP4 addresses from the collection.</param>
-        /// <param name="result3">Excluded addresses from the collection.</param>
-        /// <param name="result4">Excluded IP4 addresses from the collection.</param>
-        /// <param name="result5">Network addresses of the collection.</param>
-        [Theory]
-        [InlineData(
-            "127.0.0.1#",
-            "[]",
-            "[]",
-            "[]",
-            "[]",
-            "[]")]
-        [InlineData(
-            "!127.0.0.1",
-            "[]",
-            "[]",
-            "[127.0.0.1/32]",
-            "[127.0.0.1/32]",
-            "[]")]
-        [InlineData(
-            "",
-            "[]",
-            "[]",
-            "[]",
-            "[]",
-            "[]")]
-        [InlineData(
-            "192.158.1.2/16, localhost, fd23:184f:2029:0:3139:7386:67d7:d517,    !10.10.10.10",
-            "[192.158.1.2/16,[127.0.0.1/32,::1/128],fd23:184f:2029:0:3139:7386:67d7:d517/128]",
-            "[192.158.1.2/16,127.0.0.1/32]",
-            "[10.10.10.10/32]",
-            "[10.10.10.10/32]",
-            "[192.158.0.0/16,127.0.0.1/32,::1/128,fd23:184f:2029:0:3139:7386:67d7:d517/128]")]
-        [InlineData(
-            "192.158.1.2/255.255.0.0,192.169.1.2/8",
-            "[192.158.1.2/16,192.169.1.2/8]",
-            "[192.158.1.2/16,192.169.1.2/8]",
-            "[]",
-            "[]",
-            "[192.158.0.0/16,192.0.0.0/8]")]
-        public void TestCollections(string settings, string result1, string result2, string result3, string result4, string result5)
-        {
-            if (settings == null)
-            {
-                throw new ArgumentNullException(nameof(settings));
-            }
-
-            var conf = new NetworkConfiguration()
-            {
-                EnableIPV6 = true,
-                EnableIPV4 = true,
-            };
-
-            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
-
-            // Test included.
-            Collection<IPObject> nc = nm.CreateIPCollection(settings.Split(','), false);
-            Assert.Equal(nc.AsString(), result1);
-
-            // Test excluded.
-            nc = nm.CreateIPCollection(settings.Split(','), true);
-            Assert.Equal(nc.AsString(), result3);
-
-            conf.EnableIPV6 = false;
-            nm.UpdateSettings(conf);
-
-            // Test IP4 included.
-            nc = nm.CreateIPCollection(settings.Split(','), false);
-            Assert.Equal(nc.AsString(), result2);
-
-            // Test IP4 excluded.
-            nc = nm.CreateIPCollection(settings.Split(','), true);
-            Assert.Equal(nc.AsString(), result4);
-
-            conf.EnableIPV6 = true;
-            nm.UpdateSettings(conf);
-
-            // Test network addresses of collection.
-            nc = nm.CreateIPCollection(settings.Split(','), false);
-            nc = nc.AsNetworks();
-            Assert.Equal(nc.AsString(), result5);
-        }
-
-        /// <summary>
-        /// Union two collections.
-        /// </summary>
-        /// <param name="settings">Source.</param>
-        /// <param name="compare">Destination.</param>
-        /// <param name="result">Result.</param>
-        [Theory]
-        [InlineData("127.0.0.1", "fd23:184f:2029:0:3139:7386:67d7:d517/64,fd23:184f:2029:0:c0f0:8a8a:7605:fffa/128,fe80::3139:7386:67d7:d517%16/64,192.168.1.208/24,::1/128,127.0.0.1/8", "[127.0.0.1/32]")]
-        [InlineData("127.0.0.1", "127.0.0.1/8", "[127.0.0.1/32]")]
-        public void UnionCheck(string settings, string compare, string result)
-        {
-            if (settings == null)
-            {
-                throw new ArgumentNullException(nameof(settings));
-            }
-
-            if (compare == null)
-            {
-                throw new ArgumentNullException(nameof(compare));
-            }
-
-            if (result == null)
-            {
-                throw new ArgumentNullException(nameof(result));
-            }
-
-            var conf = new NetworkConfiguration()
-            {
-                EnableIPV6 = true,
-                EnableIPV4 = true,
-            };
-
-            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
-
-            Collection<IPObject> nc1 = nm.CreateIPCollection(settings.Split(','), false);
-            Collection<IPObject> nc2 = nm.CreateIPCollection(compare.Split(','), false);
-
-            Assert.Equal(nc1.ThatAreContainedInNetworks(nc2).AsString(), result);
+            Assert.Equal(value, "[" + String.Join(",", nm.GetInternalBindAddresses().Select(x => x.Address + "/" + x.Subnet.PrefixLength)) + "]");
         }
 
         [Theory]
@@ -194,8 +71,11 @@ namespace Jellyfin.Networking.Tests
         [InlineData("127.0.0.1/8", "127.0.0.1")]
         public void IpV4SubnetMaskMatchesValidIpAddress(string netMask, string ipAddress)
         {
-            var ipAddressObj = IPNetAddress.Parse(netMask);
-            Assert.True(ipAddressObj.Contains(IPAddress.Parse(ipAddress)));
+            var split = netMask.Split("/");
+            var mask = int.Parse(split[1], CultureInfo.InvariantCulture);
+            var ipa = IPAddress.Parse(split[0]);
+            var ipn = new IPNetwork(ipa, mask);
+            Assert.True(ipn.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
@@ -207,8 +87,11 @@ namespace Jellyfin.Networking.Tests
         [InlineData("10.128.240.50/30", "10.127.240.51")]
         public void IpV4SubnetMaskDoesNotMatchInvalidIpAddress(string netMask, string ipAddress)
         {
-            var ipAddressObj = IPNetAddress.Parse(netMask);
-            Assert.False(ipAddressObj.Contains(IPAddress.Parse(ipAddress)));
+            var split = netMask.Split("/");
+            var mask = int.Parse(split[1], CultureInfo.InvariantCulture);
+            var ipa = IPAddress.Parse(split[0]);
+            var ipn = new IPNetwork(ipa, mask);
+            Assert.False(ipn.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
@@ -219,8 +102,11 @@ namespace Jellyfin.Networking.Tests
         [InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0000")]
         public void IpV6SubnetMaskMatchesValidIpAddress(string netMask, string ipAddress)
         {
-            var ipAddressObj = IPNetAddress.Parse(netMask);
-            Assert.True(ipAddressObj.Contains(IPAddress.Parse(ipAddress)));
+            var split = netMask.Split("/");
+            var mask = int.Parse(split[1], CultureInfo.InvariantCulture);
+            var ipa = IPAddress.Parse(split[0]);
+            var ipn = new IPNetwork(ipa, mask);
+            Assert.True(ipn.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
@@ -231,86 +117,18 @@ namespace Jellyfin.Networking.Tests
         [InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0001")]
         public void IpV6SubnetMaskDoesNotMatchInvalidIpAddress(string netMask, string ipAddress)
         {
-            var ipAddressObj = IPNetAddress.Parse(netMask);
-            Assert.False(ipAddressObj.Contains(IPAddress.Parse(ipAddress)));
-        }
-
-        [Theory]
-        [InlineData("10.0.0.0/255.0.0.0", "10.10.10.1/32")]
-        [InlineData("10.0.0.0/8", "10.10.10.1/32")]
-        [InlineData("10.0.0.0/255.0.0.0", "10.10.10.1")]
-
-        [InlineData("10.10.0.0/255.255.0.0", "10.10.10.1/32")]
-        [InlineData("10.10.0.0/16", "10.10.10.1/32")]
-        [InlineData("10.10.0.0/255.255.0.0", "10.10.10.1")]
-
-        [InlineData("10.10.10.0/255.255.255.0", "10.10.10.1/32")]
-        [InlineData("10.10.10.0/24", "10.10.10.1/32")]
-        [InlineData("10.10.10.0/255.255.255.0", "10.10.10.1")]
-
-        public void TestSubnetContains(string network, string ip)
-        {
-            Assert.True(IPNetAddress.TryParse(network, out var networkObj));
-            Assert.True(IPNetAddress.TryParse(ip, out var ipObj));
-            Assert.True(networkObj.Contains(ipObj));
-        }
-
-        [Theory]
-        [InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "172.168.1.2/24", "172.168.1.2/24")]
-        [InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "172.168.1.2/24, 10.10.10.1", "172.168.1.2/24,10.10.10.1/24")]
-        [InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "192.168.1.2/255.255.255.0, 10.10.10.1", "192.168.1.2/24,10.10.10.1/24")]
-        [InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "192.168.1.2/24, 100.10.10.1", "192.168.1.2/24")]
-        [InlineData("192.168.1.2/24,10.10.10.1/24,172.168.1.2/24", "194.168.1.2/24, 100.10.10.1", "")]
-
-        public void TestCollectionEquality(string source, string dest, string result)
-        {
-            if (source == null)
-            {
-                throw new ArgumentNullException(nameof(source));
-            }
-
-            if (dest == null)
-            {
-                throw new ArgumentNullException(nameof(dest));
-            }
-
-            if (result == null)
-            {
-                throw new ArgumentNullException(nameof(result));
-            }
-
-            var conf = new NetworkConfiguration()
-            {
-                EnableIPV6 = true,
-                EnableIPV4 = true
-            };
-
-            using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
-
-            // Test included, IP6.
-            Collection<IPObject> ncSource = nm.CreateIPCollection(source.Split(','));
-            Collection<IPObject> ncDest = nm.CreateIPCollection(dest.Split(','));
-            Collection<IPObject> ncResult = ncSource.ThatAreContainedInNetworks(ncDest);
-            Collection<IPObject> resultCollection = nm.CreateIPCollection(result.Split(','));
-            Assert.True(ncResult.Compare(resultCollection));
-        }
-
-        [Theory]
-        [InlineData("10.1.1.1/32", "10.1.1.1")]
-        [InlineData("192.168.1.254/32", "192.168.1.254/255.255.255.255")]
-
-        public void TestEquals(string source, string dest)
-        {
-            Assert.True(IPNetAddress.Parse(source).Equals(IPNetAddress.Parse(dest)));
-            Assert.True(IPNetAddress.Parse(dest).Equals(IPNetAddress.Parse(source)));
+            var split = netMask.Split("/");
+            var mask = int.Parse(split[1], CultureInfo.InvariantCulture);
+            var ipa = IPAddress.Parse(split[0]);
+            var ipn = new IPNetwork(ipa, mask);
+            Assert.False(ipn.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
-
         // Testing bind interfaces.
         // On my system eth16 is internal, eth11 external (Windows defines the indexes).
         //
-        // This test is to replicate how DNLA requests work throughout the system.
+        // This test is to replicate how DLNA requests work throughout the system.
 
         // User on internal network, we're bound internal and external - so result is internal.
         [InlineData("192.168.1.1", "eth16,eth11", false, "eth16")]
@@ -357,14 +175,14 @@ namespace Jellyfin.Networking.Tests
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
             NetworkManager.MockNetworkSettings = string.Empty;
 
-            _ = nm.TryParseInterface(result, out Collection<IPObject>? resultObj);
+            _ = nm.TryParseInterface(result, out Collection<IPData>? resultObj);
 
             // Check to see if dns resolution is working. If not, skip test.
-            _ = IPHost.TryParse(source, out var host);
+            _ = NetworkExtensions.TryParseHost(source, out var host);
 
-            if (resultObj != null && host?.HasAddress == true)
+            if (resultObj != null && host.Length > 0)
             {
-                result = ((IPNetAddress)resultObj[0]).ToString(true);
+                result = resultObj.First().Address.ToString();
                 var intf = nm.GetBindInterface(source, out _);
 
                 Assert.Equal(intf, result);
@@ -394,7 +212,7 @@ namespace Jellyfin.Networking.Tests
         [InlineData("jellyfin.org", "192.168.1.0/24", "eth16", false, "0.0.0.0=http://helloworld.com", "http://helloworld.com")]
 
         // User on external network, no binding - so result is the 1st external which is overriden.
-        [InlineData("jellyfin.org", "192.168.1.0/24", "", false, "0.0.0.0 = http://helloworld.com", "http://helloworld.com")]
+        [InlineData("jellyfin.org", "192.168.1.0/24", "", false, "0.0.0.0=http://helloworld.com", "http://helloworld.com")]
 
         // User assumed to be internal, no binding - so result is the 1st internal.
         [InlineData("", "192.168.1.0/24", "", false, "0.0.0.0=http://helloworld.com", "eth16")]
@@ -426,15 +244,15 @@ namespace Jellyfin.Networking.Tests
             using var nm = new NetworkManager(GetMockConfig(conf), new NullLogger<NetworkManager>());
             NetworkManager.MockNetworkSettings = string.Empty;
 
-            if (nm.TryParseInterface(result, out Collection<IPObject>? resultObj) && resultObj != null)
+            if (nm.TryParseInterface(result, out Collection<IPData>? resultObj) && resultObj != null)
             {
                 // Parse out IPAddresses so we can do a string comparison. (Ignore subnet masks).
-                result = ((IPNetAddress)resultObj[0]).ToString(true);
+                result = resultObj.First().Address.ToString();
             }
 
             var intf = nm.GetBindInterface(source, out int? _);
 
-            Assert.Equal(intf, result);
+            Assert.Equal(result, intf);
         }
 
         [Theory]
@@ -461,6 +279,7 @@ namespace Jellyfin.Networking.Tests
         [InlineData("185.10.10.10", "79.2.3.4", false)]
         [InlineData("185.10.10.10", "185.10.10.10", true)]
         [InlineData("", "100.100.100.100", false)]
+
         public void HasRemoteAccess_GivenBlacklist_BlacklistTheIps(string addresses, string remoteIp, bool denied)
         {
             // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.