< Summary - Jellyfin

Information
Class: Jellyfin.Networking.Manager.NetworkManager
Assembly: Jellyfin.Networking
File(s): /srv/git/jellyfin/src/Jellyfin.Networking/Manager/NetworkManager.cs
Line coverage
75%
Covered lines: 358
Uncovered lines: 118
Coverable lines: 476
Total lines: 1131
Line coverage: 75.2%
Branch coverage
66%
Covered branches: 179
Total branches: 268
Branch coverage: 66.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%22100%
.cctor()100%11100%
get_IsIPv4Enabled()100%11100%
get_IsIPv6Enabled()100%11100%
get_PublishedServerUrls()100%210%
Dispose()100%11100%
OnNetworkAvailabilityChanged(...)100%210%
OnNetworkAddressChanged(...)100%210%
HandleNetworkChange()0%620%
OnNetworkChange()0%4260%
InitializeInterfaces()77.77%231874.41%
InitializeLan(...)90%101095.45%
EnforceBindSettings(...)77.27%232289.65%
InitializeRemote(...)83.33%121292.85%
InitializeOverrides(...)72.72%352269.87%
ConfigurationUpdated(...)50%2266.66%
UpdateSettings(...)80%101096.15%
Dispose(...)100%44100%
TryParseInterface(...)50%6683.33%
HasRemoteAccess(...)87.5%181681.81%
GetLoopbacks()0%7280%
GetAllBindInterfaces(...)44.44%441857.14%
GetBindAddress(...)100%22100%
GetBindAddress(...)0%620%
GetBindAddress(...)69.44%663671.42%
GetInternalBindAddresses()100%11100%
IsInLocalNetwork(...)0%2040%
IsLinkLocalAddress(...)50%22100%
IsInLocalNetwork(...)62.5%9871.42%
CheckIfLanAndNotExcluded(...)100%88100%
MatchesPublishedServerUrl(...)68.18%232285.71%
MatchesBindInterface(...)78.57%141494.11%
MatchesExternalInterface(...)16.66%10652.94%
PrintNetworkInformation(...)66.66%66100%

File(s)

/srv/git/jellyfin/src/Jellyfin.Networking/Manager/NetworkManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Diagnostics.CodeAnalysis;
 4using System.Globalization;
 5using System.Linq;
 6using System.Net;
 7using System.Net.NetworkInformation;
 8using System.Net.Sockets;
 9using System.Threading;
 10using MediaBrowser.Common.Configuration;
 11using MediaBrowser.Common.Net;
 12using MediaBrowser.Model.Net;
 13using Microsoft.AspNetCore.Http;
 14using Microsoft.Extensions.Configuration;
 15using Microsoft.Extensions.Logging;
 16using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
 17using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
 18using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 19
 20namespace Jellyfin.Networking.Manager;
 21
 22/// <summary>
 23/// Class to take care of network interface management.
 24/// </summary>
 25public class NetworkManager : INetworkManager, IDisposable
 26{
 27    /// <summary>
 28    /// Threading lock for network properties.
 29    /// </summary>
 30    private readonly Lock _initLock;
 31
 32    private readonly ILogger<NetworkManager> _logger;
 33
 34    private readonly IConfigurationManager _configurationManager;
 35
 36    private readonly IConfiguration _startupConfig;
 37
 38    private readonly Lock _networkEventLock;
 39
 40    /// <summary>
 41    /// Holds the published server URLs and the IPs to use them on.
 42    /// </summary>
 43    private IReadOnlyList<PublishedServerUriOverride> _publishedServerUrls;
 44
 45    private IReadOnlyList<IPNetwork> _remoteAddressFilter;
 46
 47    /// <summary>
 48    /// Used to stop "event-racing conditions".
 49    /// </summary>
 50    private bool _eventfire;
 51
 52    /// <summary>
 53    /// Dictionary containing interface addresses and their subnets.
 54    /// </summary>
 55    private List<IPData> _interfaces;
 56
 57    /// <summary>
 58    /// Unfiltered user defined LAN subnets (<see cref="NetworkConfiguration.LocalNetworkSubnets"/>)
 59    /// or internal interface network subnets if undefined by user.
 60    /// </summary>
 61    private IReadOnlyList<IPNetwork> _lanSubnets;
 62
 63    /// <summary>
 64    /// User defined list of subnets to excluded from the LAN.
 65    /// </summary>
 66    private IReadOnlyList<IPNetwork> _excludedSubnets;
 67
 68    /// <summary>
 69    /// True if this object is disposed.
 70    /// </summary>
 71    private bool _disposed;
 72
 73    /// <summary>
 74    /// Initializes a new instance of the <see cref="NetworkManager"/> class.
 75    /// </summary>
 76    /// <param name="configurationManager">The <see cref="IConfigurationManager"/> instance.</param>
 77    /// <param name="startupConfig">The <see cref="IConfiguration"/> instance holding startup parameters.</param>
 78    /// <param name="logger">Logger to use for messages.</param>
 79    public NetworkManager(IConfigurationManager configurationManager, IConfiguration startupConfig, ILogger<NetworkManag
 80    {
 7681        ArgumentNullException.ThrowIfNull(logger);
 7682        ArgumentNullException.ThrowIfNull(configurationManager);
 83
 7684        _logger = logger;
 7685        _configurationManager = configurationManager;
 7686        _startupConfig = startupConfig;
 7687        _initLock = new();
 7688        _interfaces = new List<IPData>();
 7689        _publishedServerUrls = new List<PublishedServerUriOverride>();
 7690        _networkEventLock = new();
 7691        _remoteAddressFilter = new List<IPNetwork>();
 92
 7693        _ = bool.TryParse(startupConfig[DetectNetworkChangeKey], out var detectNetworkChange);
 94
 7695        UpdateSettings(_configurationManager.GetNetworkConfiguration());
 96
 7697        if (detectNetworkChange)
 98        {
 2199            NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
 21100            NetworkChange.NetworkAvailabilityChanged += OnNetworkAvailabilityChanged;
 101        }
 102
 76103        _configurationManager.NamedConfigurationUpdated += ConfigurationUpdated;
 76104    }
 105
 106    /// <summary>
 107    /// Event triggered on network changes.
 108    /// </summary>
 109    public event EventHandler? NetworkChanged;
 110
 111    /// <summary>
 112    /// Gets or sets a value indicating whether testing is taking place.
 113    /// </summary>
 3114    public static string MockNetworkSettings { get; set; } = string.Empty;
 115
 116    /// <summary>
 117    /// Gets a value indicating whether IP4 is enabled.
 118    /// </summary>
 378119    public bool IsIPv4Enabled => _configurationManager.GetNetworkConfiguration().EnableIPv4;
 120
 121    /// <summary>
 122    /// Gets a value indicating whether IP6 is enabled.
 123    /// </summary>
 255124    public bool IsIPv6Enabled => _configurationManager.GetNetworkConfiguration().EnableIPv6;
 125
 126    /// <summary>
 127    /// Gets a value indicating whether is all IPv6 interfaces are trusted as internal.
 128    /// </summary>
 129    public bool TrustAllIPv6Interfaces { get; private set; }
 130
 131    /// <summary>
 132    /// Gets the Published server override list.
 133    /// </summary>
 0134    public IReadOnlyList<PublishedServerUriOverride> PublishedServerUrls => _publishedServerUrls;
 135
 136    /// <inheritdoc/>
 137    public void Dispose()
 138    {
 55139        Dispose(true);
 55140        GC.SuppressFinalize(this);
 55141    }
 142
 143    /// <summary>
 144    /// Handler for network change events.
 145    /// </summary>
 146    /// <param name="sender">Sender.</param>
 147    /// <param name="e">A <see cref="NetworkAvailabilityEventArgs"/> containing network availability information.</param
 148    private void OnNetworkAvailabilityChanged(object? sender, NetworkAvailabilityEventArgs e)
 149    {
 0150        _logger.LogDebug("Network availability changed.");
 0151        HandleNetworkChange();
 0152    }
 153
 154    /// <summary>
 155    /// Handler for network change events.
 156    /// </summary>
 157    /// <param name="sender">Sender.</param>
 158    /// <param name="e">An <see cref="EventArgs"/>.</param>
 159    private void OnNetworkAddressChanged(object? sender, EventArgs e)
 160    {
 0161        _logger.LogDebug("Network address change detected.");
 0162        HandleNetworkChange();
 0163    }
 164
 165    /// <summary>
 166    /// Triggers our event, and re-loads interface information.
 167    /// </summary>
 168    private void HandleNetworkChange()
 0169    {
 170        lock (_networkEventLock)
 171        {
 0172            if (!_eventfire)
 173            {
 174                // As network events tend to fire one after the other only fire once every second.
 0175                _eventfire = true;
 0176                OnNetworkChange();
 177            }
 0178        }
 0179    }
 180
 181    /// <summary>
 182    /// Waits for 2 seconds before re-initialising the settings, as typically these events fire multiple times in succes
 183    /// </summary>
 184    private void OnNetworkChange()
 185    {
 186        try
 187        {
 0188            Thread.Sleep(2000);
 0189            var networkConfig = _configurationManager.GetNetworkConfiguration();
 0190            if (IsIPv6Enabled && !Socket.OSSupportsIPv6)
 191            {
 0192                UpdateSettings(networkConfig);
 193            }
 194            else
 195            {
 0196                InitializeInterfaces();
 0197                InitializeLan(networkConfig);
 0198                EnforceBindSettings(networkConfig);
 199            }
 200
 0201            PrintNetworkInformation(networkConfig);
 0202            NetworkChanged?.Invoke(this, EventArgs.Empty);
 0203        }
 204        finally
 205        {
 0206            _eventfire = false;
 0207        }
 0208    }
 209
 210    /// <summary>
 211    /// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
 212    /// </summary>
 213    private void InitializeInterfaces()
 37214    {
 215        lock (_initLock)
 216        {
 37217            _logger.LogDebug("Refreshing interfaces.");
 218
 37219            var interfaces = new List<IPData>();
 220
 221            try
 222            {
 37223                var nics = NetworkInterface.GetAllNetworkInterfaces()
 37224                    .Where(i => i.OperationalStatus == OperationalStatus.Up);
 225
 222226                foreach (NetworkInterface adapter in nics)
 227                {
 228                    try
 229                    {
 74230                        var ipProperties = adapter.GetIPProperties();
 231
 232                        // Populate interface list
 444233                        foreach (var info in ipProperties.UnicastAddresses)
 234                        {
 148235                            if (IsIPv4Enabled && info.Address.AddressFamily == AddressFamily.InterNetwork)
 236                            {
 74237                                var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLe
 74238                                {
 74239                                    Index = ipProperties.GetIPv4Properties().Index,
 74240                                    Name = adapter.Name,
 74241                                    SupportsMulticast = adapter.SupportsMulticast
 74242                                };
 243
 74244                                interfaces.Add(interfaceObject);
 245                            }
 74246                            else if (IsIPv6Enabled && info.Address.AddressFamily == AddressFamily.InterNetworkV6)
 247                            {
 20248                                var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLe
 20249                                {
 20250                                    Index = ipProperties.GetIPv6Properties().Index,
 20251                                    Name = adapter.Name,
 20252                                    SupportsMulticast = adapter.SupportsMulticast
 20253                                };
 254
 20255                                interfaces.Add(interfaceObject);
 256                            }
 257                        }
 74258                    }
 0259                    catch (Exception ex)
 260                    {
 261                        // Ignore error, and attempt to continue.
 0262                        _logger.LogError(ex, "Error encountered parsing interfaces.");
 0263                    }
 264                }
 37265            }
 0266            catch (Exception ex)
 267            {
 0268                _logger.LogError(ex, "Error obtaining interfaces.");
 0269            }
 270
 271            // If no interfaces are found, fallback to loopback interfaces.
 37272            if (interfaces.Count == 0)
 273            {
 0274                _logger.LogWarning("No interface information available. Using loopback interface(s).");
 275
 0276                if (IsIPv4Enabled)
 277                {
 0278                    interfaces.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 279                }
 280
 0281                if (IsIPv6Enabled)
 282                {
 0283                    interfaces.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 284                }
 285            }
 286
 37287            _logger.LogDebug("Discovered {NumberOfInterfaces} interfaces.", interfaces.Count);
 37288            _logger.LogDebug("Interfaces addresses: {Addresses}", interfaces.OrderByDescending(s => s.AddressFamily == A
 289
 37290            _interfaces = interfaces;
 37291        }
 37292    }
 293
 294    /// <summary>
 295    /// Initializes internal LAN cache.
 296    /// </summary>
 297    [MemberNotNull(nameof(_lanSubnets), nameof(_excludedSubnets))]
 298    private void InitializeLan(NetworkConfiguration config)
 76299    {
 300        lock (_initLock)
 301        {
 76302            _logger.LogDebug("Refreshing LAN information.");
 303
 304            // Get configuration options
 76305            var subnets = config.LocalNetworkSubnets;
 306
 307            // If no LAN addresses are specified, all private subnets and Loopback are deemed to be the LAN
 76308            if (!NetworkUtils.TryParseToSubnets(subnets, out var lanSubnets, false) || lanSubnets.Count == 0)
 309            {
 42310                _logger.LogDebug("Using LAN interface addresses as user provided no LAN details.");
 311
 42312                var fallbackLanSubnets = new List<IPNetwork>();
 42313                if (IsIPv6Enabled)
 314                {
 7315                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4291Loopback); // RFC 4291 (Loopback)
 7316                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4291SiteLocal); // RFC 4291 (Site local)
 7317                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4193UniqueLocal); // RFC 4193 (Unique local)
 318                }
 319
 42320                if (IsIPv4Enabled)
 321                {
 42322                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC5735Loopback); // RFC 5735 (Loopback)
 42323                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassA); // RFC 1918 (private Class A)
 42324                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassB); // RFC 1918 (private Class B)
 42325                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassC); // RFC 1918 (private Class C)
 326                }
 327
 42328                _lanSubnets = fallbackLanSubnets;
 329            }
 330            else
 331            {
 34332                _lanSubnets = lanSubnets;
 333            }
 334
 76335            _excludedSubnets = NetworkUtils.TryParseToSubnets(subnets, out var excludedSubnets, true)
 76336                ? excludedSubnets
 76337                : new List<IPNetwork>();
 76338        }
 76339    }
 340
 341    /// <summary>
 342    /// Enforce bind addresses and exclusions on available interfaces.
 343    /// </summary>
 344    private void EnforceBindSettings(NetworkConfiguration config)
 76345    {
 346        lock (_initLock)
 347        {
 348            // Respect explicit bind addresses
 76349            var interfaces = _interfaces.ToList();
 76350            var localNetworkAddresses = config.LocalNetworkAddresses;
 76351            if (localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]))
 352            {
 12353                var bindAddresses = localNetworkAddresses.Select(p => NetworkUtils.TryParseToSubnet(p, out var network)
 12354                        ? network.Prefix
 12355                        : (interfaces.Where(x => x.Name.Equals(p, StringComparison.OrdinalIgnoreCase))
 12356                            .Select(x => x.Address)
 12357                            .FirstOrDefault() ?? IPAddress.None))
 12358                    .Where(x => x != IPAddress.None)
 12359                    .ToHashSet();
 12360                interfaces = interfaces.Where(x => bindAddresses.Contains(x.Address)).ToList();
 361
 12362                if (bindAddresses.Contains(IPAddress.Loopback) && !interfaces.Any(i => i.Address.Equals(IPAddress.Loopba
 363                {
 0364                    interfaces.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 365                }
 366
 12367                if (bindAddresses.Contains(IPAddress.IPv6Loopback) && !interfaces.Any(i => i.Address.Equals(IPAddress.IP
 368                {
 0369                    interfaces.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 370                }
 371            }
 372
 373            // Remove all interfaces matching any virtual machine interface prefix
 76374            if (config.IgnoreVirtualInterfaces)
 375            {
 376                // Remove potentially existing * and split config string into prefixes
 76377                var virtualInterfacePrefixes = config.VirtualInterfaceNames
 76378                    .Select(i => i.Replace("*", string.Empty, StringComparison.OrdinalIgnoreCase));
 379
 380                // Check all interfaces for matches against the prefixes and remove them
 76381                if (_interfaces.Count > 0)
 382                {
 304383                    foreach (var virtualInterfacePrefix in virtualInterfacePrefixes)
 384                    {
 76385                        interfaces.RemoveAll(x => x.Name.StartsWith(virtualInterfacePrefix, StringComparison.OrdinalIgno
 386                    }
 387                }
 388            }
 389
 390            // Remove all IPv4 interfaces if IPv4 is disabled
 76391            if (!IsIPv4Enabled)
 392            {
 0393                interfaces.RemoveAll(x => x.AddressFamily == AddressFamily.InterNetwork);
 394            }
 395
 396            // Remove all IPv6 interfaces if IPv6 is disabled
 76397            if (!IsIPv6Enabled)
 398            {
 52399                interfaces.RemoveAll(x => x.AddressFamily == AddressFamily.InterNetworkV6);
 400            }
 401
 402            // Users may have complex networking configuration that multiple interfaces sharing the same IP address
 403            // Only return one IP for binding, and let the OS handle the rest
 76404            _interfaces = interfaces.DistinctBy(iface => iface.Address).ToList();
 76405        }
 76406    }
 407
 408    /// <summary>
 409    /// Initializes the remote address values.
 410    /// </summary>
 411    private void InitializeRemote(NetworkConfiguration config)
 76412    {
 413        lock (_initLock)
 414        {
 415            // Parse config values into filter collection
 76416            var remoteIPFilter = config.RemoteIPFilter;
 76417            if (remoteIPFilter.Length != 0 && !string.IsNullOrWhiteSpace(remoteIPFilter[0]))
 418            {
 419                // Parse all IPs with netmask to a subnet
 4420                var remoteAddressFilter = new List<IPNetwork>();
 4421                var remoteFilteredSubnets = remoteIPFilter.Where(x => x.Contains('/', StringComparison.OrdinalIgnoreCase
 4422                if (NetworkUtils.TryParseToSubnets(remoteFilteredSubnets, out var remoteAddressFilterResult, false))
 423                {
 0424                    remoteAddressFilter = remoteAddressFilterResult.ToList();
 425                }
 426
 427                // Parse everything else as an IP and construct subnet with a single IP
 4428                var remoteFilteredIPs = remoteIPFilter.Where(x => !x.Contains('/', StringComparison.OrdinalIgnoreCase));
 18429                foreach (var ip in remoteFilteredIPs)
 430                {
 5431                    if (IPAddress.TryParse(ip, out var ipp))
 432                    {
 5433                        remoteAddressFilter.Add(new IPNetwork(ipp, ipp.AddressFamily == AddressFamily.InterNetwork ? Net
 434                    }
 435                }
 436
 4437                _remoteAddressFilter = remoteAddressFilter;
 438            }
 76439        }
 76440    }
 441
 442    /// <summary>
 443    /// Parses the user defined overrides into the dictionary object.
 444    /// Overrides are the equivalent of localised publishedServerUrl, enabling
 445    /// different addresses to be advertised over different subnets.
 446    /// format is subnet=ipaddress|host|uri
 447    /// when subnet = 0.0.0.0, any external address matches.
 448    /// </summary>
 449    private void InitializeOverrides(NetworkConfiguration config)
 76450    {
 451        lock (_initLock)
 452        {
 76453            var publishedServerUrls = new List<PublishedServerUriOverride>();
 454
 455            // Prefer startup configuration.
 76456            var startupOverrideKey = _startupConfig[AddressOverrideKey];
 76457            if (!string.IsNullOrEmpty(startupOverrideKey))
 458            {
 0459                publishedServerUrls.Add(
 0460                    new PublishedServerUriOverride(
 0461                        new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 0462                        startupOverrideKey,
 0463                        true,
 0464                        true));
 0465                publishedServerUrls.Add(
 0466                    new PublishedServerUriOverride(
 0467                        new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 0468                        startupOverrideKey,
 0469                        true,
 0470                        true));
 0471                _publishedServerUrls = publishedServerUrls;
 0472                return;
 473            }
 474
 76475            var overrides = config.PublishedServerUriBySubnet;
 166476            foreach (var entry in overrides)
 477            {
 8478                var parts = entry.Split('=');
 8479                if (parts.Length != 2)
 480                {
 0481                    _logger.LogError("Unable to parse bind override: {Entry}", entry);
 0482                    return;
 483                }
 484
 8485                var replacement = parts[1].Trim();
 8486                var identifier = parts[0];
 8487                if (string.Equals(identifier, "all", StringComparison.OrdinalIgnoreCase))
 488                {
 489                    // Drop any other overrides in case an "all" override exists
 2490                    publishedServerUrls.Clear();
 2491                    publishedServerUrls.Add(
 2492                        new PublishedServerUriOverride(
 2493                            new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 2494                            replacement,
 2495                            true,
 2496                            true));
 2497                    publishedServerUrls.Add(
 2498                        new PublishedServerUriOverride(
 2499                            new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 2500                            replacement,
 2501                            true,
 2502                            true));
 2503                    break;
 504                }
 6505                else if (string.Equals(identifier, "external", StringComparison.OrdinalIgnoreCase))
 506                {
 4507                    publishedServerUrls.Add(
 4508                        new PublishedServerUriOverride(
 4509                            new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 4510                            replacement,
 4511                            false,
 4512                            true));
 4513                    publishedServerUrls.Add(
 4514                        new PublishedServerUriOverride(
 4515                            new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 4516                            replacement,
 4517                            false,
 4518                            true));
 519                }
 2520                else if (string.Equals(identifier, "internal", StringComparison.OrdinalIgnoreCase))
 521                {
 0522                    foreach (var lan in _lanSubnets)
 523                    {
 0524                        var lanPrefix = lan.Prefix;
 0525                        publishedServerUrls.Add(
 0526                            new PublishedServerUriOverride(
 0527                                new IPData(lanPrefix, new IPNetwork(lanPrefix, lan.PrefixLength)),
 0528                                replacement,
 0529                                true,
 0530                                false));
 531                    }
 532                }
 2533                else if (NetworkUtils.TryParseToSubnet(identifier, out var result) && result is not null)
 534                {
 1535                    var data = new IPData(result.Prefix, result);
 1536                    publishedServerUrls.Add(
 1537                        new PublishedServerUriOverride(
 1538                            data,
 1539                            replacement,
 1540                            true,
 1541                            true));
 542                }
 1543                else if (TryParseInterface(identifier, out var ifaces))
 544                {
 4545                    foreach (var iface in ifaces)
 546                    {
 1547                        publishedServerUrls.Add(
 1548                            new PublishedServerUriOverride(
 1549                                iface,
 1550                                replacement,
 1551                                true,
 1552                                true));
 553                    }
 554                }
 555                else
 556                {
 0557                    _logger.LogError("Unable to parse bind override: {Entry}", entry);
 558                }
 559            }
 560
 76561            _publishedServerUrls = publishedServerUrls;
 76562        }
 76563    }
 564
 565    private void ConfigurationUpdated(object? sender, ConfigurationUpdateEventArgs evt)
 566    {
 22567        if (evt.Key.Equals(NetworkConfigurationStore.StoreKey, StringComparison.Ordinal))
 568        {
 0569            UpdateSettings((NetworkConfiguration)evt.NewConfiguration);
 570        }
 22571    }
 572
 573    /// <summary>
 574    /// Reloads all settings and re-Initializes the instance.
 575    /// </summary>
 576    /// <param name="configuration">The <see cref="NetworkConfiguration"/> to use.</param>
 577    [MemberNotNull(nameof(_lanSubnets), nameof(_excludedSubnets))]
 578    public void UpdateSettings(object configuration)
 579    {
 76580        ArgumentNullException.ThrowIfNull(configuration);
 581
 76582        var config = (NetworkConfiguration)configuration;
 76583        HappyEyeballs.HttpClientExtension.UseIPv6 = config.EnableIPv6;
 584
 76585        InitializeLan(config);
 76586        InitializeRemote(config);
 587
 76588        if (string.IsNullOrEmpty(MockNetworkSettings))
 589        {
 37590            InitializeInterfaces();
 591        }
 592        else // Used in testing only.
 593        {
 594            // Format is <IPAddress>,<Index>,<Name>: <next interface>. Set index to -ve to simulate a gateway.
 39595            var interfaceList = MockNetworkSettings.Split('|');
 39596            var interfaces = new List<IPData>();
 236597            foreach (var details in interfaceList)
 598            {
 79599                var parts = details.Split(',');
 79600                if (NetworkUtils.TryParseToSubnet(parts[0], out var subnet))
 601                {
 79602                    var address = subnet.Prefix;
 79603                    var index = int.Parse(parts[1], CultureInfo.InvariantCulture);
 79604                    if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.In
 605                    {
 79606                        var data = new IPData(address, subnet, parts[2])
 79607                        {
 79608                            Index = index
 79609                        };
 79610                        interfaces.Add(data);
 611                    }
 612                }
 613                else
 614                {
 0615                    _logger.LogWarning("Could not parse mock interface settings: {Part}", details);
 616                }
 617            }
 618
 39619            _interfaces = interfaces;
 620        }
 621
 76622        EnforceBindSettings(config);
 76623        InitializeOverrides(config);
 624
 76625        PrintNetworkInformation(config, false);
 76626    }
 627
 628    /// <summary>
 629    /// Protected implementation of Dispose pattern.
 630    /// </summary>
 631    /// <param name="disposing"><c>True</c> to dispose the managed state.</param>
 632    protected virtual void Dispose(bool disposing)
 633    {
 55634        if (!_disposed)
 635        {
 55636            if (disposing)
 637            {
 55638                _configurationManager.NamedConfigurationUpdated -= ConfigurationUpdated;
 55639                NetworkChange.NetworkAddressChanged -= OnNetworkAddressChanged;
 55640                NetworkChange.NetworkAvailabilityChanged -= OnNetworkAvailabilityChanged;
 641            }
 642
 55643            _disposed = true;
 644        }
 55645    }
 646
 647    /// <inheritdoc/>
 648    public bool TryParseInterface(string intf, [NotNullWhen(true)] out IReadOnlyList<IPData>? result)
 649    {
 15650        if (string.IsNullOrEmpty(intf)
 15651            || _interfaces is null
 15652            || _interfaces.Count == 0)
 653        {
 0654            result = null;
 0655            return false;
 656        }
 657
 658        // Match all interfaces starting with names starting with token
 15659        result = _interfaces
 15660            .Where(i => i.Name.Equals(intf, StringComparison.OrdinalIgnoreCase)
 15661                        && ((IsIPv4Enabled && i.Address.AddressFamily == AddressFamily.InterNetwork)
 15662                            || (IsIPv6Enabled && i.Address.AddressFamily == AddressFamily.InterNetworkV6)))
 15663            .OrderBy(x => x.Index)
 15664            .ToArray();
 15665        return result.Count > 0;
 666    }
 667
 668    /// <inheritdoc/>
 669    public bool HasRemoteAccess(IPAddress remoteIP)
 670    {
 6671        var config = _configurationManager.GetNetworkConfiguration();
 6672        if (config.EnableRemoteAccess)
 673        {
 674            // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect r
 675            // If left blank, all remote addresses will be allowed.
 6676            if (_remoteAddressFilter.Any() && !IsInLocalNetwork(remoteIP))
 677            {
 678                // remoteAddressFilter is a whitelist or blacklist.
 4679                var matches = _remoteAddressFilter.Count(remoteNetwork => NetworkUtils.SubnetContainsAddress(remoteNetwo
 4680                if ((!config.IsRemoteIPFilterBlacklist && matches > 0)
 4681                    || (config.IsRemoteIPFilterBlacklist && matches == 0))
 682                {
 2683                    return true;
 684                }
 685
 2686                return false;
 687            }
 688        }
 0689        else if (!IsInLocalNetwork(remoteIP))
 690        {
 691            // Remote not enabled. So everyone should be LAN.
 0692            return false;
 693        }
 694
 2695        return true;
 696    }
 697
 698    /// <inheritdoc/>
 699    public IReadOnlyList<IPData> GetLoopbacks()
 700    {
 0701        if (!IsIPv4Enabled && !IsIPv6Enabled)
 702        {
 0703            return Array.Empty<IPData>();
 704        }
 705
 0706        var loopbackNetworks = new List<IPData>();
 0707        if (IsIPv4Enabled)
 708        {
 0709            loopbackNetworks.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 710        }
 711
 0712        if (IsIPv6Enabled)
 713        {
 0714            loopbackNetworks.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 715        }
 716
 0717        return loopbackNetworks;
 718    }
 719
 720    /// <inheritdoc/>
 721    public IReadOnlyList<IPData> GetAllBindInterfaces(bool individualInterfaces = false)
 722    {
 21723        var config = _configurationManager.GetNetworkConfiguration();
 21724        var localNetworkAddresses = config.LocalNetworkAddresses;
 21725        if ((localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]) && _interfaces.Cou
 726        {
 0727            return _interfaces;
 728        }
 729
 730        // No bind address and no exclusions, so listen on all interfaces.
 21731        var result = new List<IPData>();
 21732        if (IsIPv4Enabled && IsIPv6Enabled)
 733        {
 734            // Kestrel source code shows it uses Sockets.DualMode - so this also covers IPAddress.Any by default
 0735            result.Add(new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any));
 736        }
 21737        else if (IsIPv4Enabled)
 738        {
 21739            result.Add(new IPData(IPAddress.Any, NetworkConstants.IPv4Any));
 740        }
 0741        else if (IsIPv6Enabled)
 742        {
 743            // Cannot use IPv6Any as Kestrel will bind to IPv4 addresses too.
 0744            foreach (var iface in _interfaces)
 745            {
 0746                if (iface.AddressFamily == AddressFamily.InterNetworkV6)
 747                {
 0748                    result.Add(iface);
 749                }
 750            }
 751        }
 752
 21753        return result;
 754    }
 755
 756    /// <inheritdoc/>
 757    public string GetBindAddress(string source, out int? port)
 758    {
 23759        if (!NetworkUtils.TryParseHost(source, out var addresses, IsIPv4Enabled, IsIPv6Enabled))
 760        {
 4761            addresses = Array.Empty<IPAddress>();
 762        }
 763
 23764        var result = GetBindAddress(addresses.FirstOrDefault(), out port);
 23765        return result;
 766    }
 767
 768    /// <inheritdoc/>
 769    public string GetBindAddress(HttpRequest source, out int? port)
 770    {
 0771        var result = GetBindAddress(source.Host.Host, out port);
 0772        port ??= source.Host.Port;
 773
 0774        return result;
 775    }
 776
 777    /// <inheritdoc/>
 778    public string GetBindAddress(IPAddress? source, out int? port, bool skipOverrides = false)
 779    {
 23780        port = null;
 781
 782        string result;
 783
 23784        if (source is not null)
 785        {
 19786            if (IsIPv4Enabled && !IsIPv6Enabled && source.AddressFamily == AddressFamily.InterNetworkV6)
 787            {
 0788                _logger.LogWarning("IPv6 is disabled in Jellyfin, but enabled in the OS. This may affect how the interfa
 789            }
 790
 19791            if (!IsIPv4Enabled && IsIPv6Enabled && source.AddressFamily == AddressFamily.InterNetwork)
 792            {
 0793                _logger.LogWarning("IPv4 is disabled in Jellyfin, but enabled in the OS. This may affect how the interfa
 794            }
 795
 19796            bool isExternal = !IsInLocalNetwork(source);
 19797            _logger.LogDebug("Trying to get bind address for source {Source} - External: {IsExternal}", source, isExtern
 798
 19799            if (!skipOverrides && MatchesPublishedServerUrl(source, isExternal, out result))
 800            {
 6801                return result;
 802            }
 803
 804            // No preference given, so move on to bind addresses.
 13805            if (MatchesBindInterface(source, isExternal, out result))
 806            {
 11807                return result;
 808            }
 809
 2810            if (isExternal && MatchesExternalInterface(source, out result))
 811            {
 0812                return result;
 813            }
 814        }
 815
 816        // Get the first LAN interface address that's not excluded and not a loopback address.
 817        // Get all available interfaces, prefer local interfaces
 6818        var availableInterfaces = _interfaces.Where(x => !IPAddress.IsLoopback(x.Address))
 6819            .OrderByDescending(x => IsInLocalNetwork(x.Address))
 6820            .ThenBy(x => x.Index)
 6821            .ToList();
 822
 6823        if (availableInterfaces.Count == 0)
 824        {
 825            // There isn't any others, so we'll use the loopback.
 0826            result = IsIPv4Enabled && !IsIPv6Enabled ? "127.0.0.1" : "::1";
 0827            _logger.LogWarning("{Source}: Only loopback {Result} returned, using that as bind address.", source, result)
 0828            return result;
 829        }
 830
 831        // If no source address is given, use the preferred (first) interface
 6832        if (source is null)
 833        {
 4834            result = NetworkUtils.FormatIPString(availableInterfaces.First().Address);
 4835            _logger.LogDebug("{Source}: Using first internal interface as bind address: {Result}", source, result);
 4836            return result;
 837        }
 838
 839        // Does the request originate in one of the interface subnets?
 840        // (For systems with multiple internal network cards, and multiple subnets)
 8841        foreach (var intf in availableInterfaces)
 842        {
 2843            if (NetworkUtils.SubnetContainsAddress(intf.Subnet, source))
 844            {
 0845                result = NetworkUtils.FormatIPString(intf.Address);
 0846                _logger.LogDebug("{Source}: Found interface with matching subnet, using it as bind address: {Result}", s
 0847                return result;
 848            }
 849        }
 850
 851        // Fallback to first available interface
 2852        result = NetworkUtils.FormatIPString(availableInterfaces[0].Address);
 2853        _logger.LogDebug("{Source}: No matching interfaces found, using preferred interface as bind address: {Result}", 
 2854        return result;
 0855    }
 856
 857    /// <inheritdoc/>
 858    public IReadOnlyList<IPData> GetInternalBindAddresses()
 859    {
 860        // Select all local bind addresses
 6861        return _interfaces.Where(x => IsInLocalNetwork(x.Address))
 6862            .OrderBy(x => x.Index)
 6863            .ToList();
 864    }
 865
 866    /// <inheritdoc/>
 867    public bool IsInLocalNetwork(string address)
 868    {
 0869        if (NetworkUtils.TryParseToSubnet(address, out var subnet))
 870        {
 0871            return IsInLocalNetwork(subnet.Prefix);
 872        }
 873
 0874        return NetworkUtils.TryParseHost(address, out var addresses, IsIPv4Enabled, IsIPv6Enabled)
 0875               && addresses.Any(IsInLocalNetwork);
 876    }
 877
 878    /// <summary>
 879    ///  Get if the IPAddress is Link-local.
 880    /// </summary>
 881    /// <param name="address">The IP Address.</param>
 882    /// <returns>Bool indicates if the address is link-local.</returns>
 883    public bool IsLinkLocalAddress(IPAddress address)
 884    {
 4885        ArgumentNullException.ThrowIfNull(address);
 4886        return NetworkConstants.IPv4RFC3927LinkLocal.Contains(address) || address.IsIPv6LinkLocal;
 887    }
 888
 889    /// <inheritdoc/>
 890    public bool IsInLocalNetwork(IPAddress address)
 891    {
 157892        ArgumentNullException.ThrowIfNull(address);
 893
 894        // Map IPv6 mapped IPv4 back to IPv4 (happens if Kestrel runs in dual-socket mode)
 157895        if (address.IsIPv4MappedToIPv6)
 896        {
 0897            address = address.MapToIPv4();
 898        }
 899
 157900        if ((TrustAllIPv6Interfaces && address.AddressFamily == AddressFamily.InterNetworkV6)
 157901            || IPAddress.IsLoopback(address))
 902        {
 85903            return true;
 904        }
 905
 906        // As private addresses can be redefined by Configuration.LocalNetworkAddresses
 72907        return CheckIfLanAndNotExcluded(address);
 908    }
 909
 910    /// <summary>
 911    /// Check if the address is in the LAN and not excluded.
 912    /// </summary>
 913    /// <param name="address">The IP address to check. The caller should make sure this is not an IPv4MappedToIPv6 addre
 914    /// <returns>Boolean indicates whether the address is in LAN.</returns>
 915    private bool CheckIfLanAndNotExcluded(IPAddress address)
 916    {
 376917        foreach (var lanSubnet in _lanSubnets)
 918        {
 135919            if (lanSubnet.Contains(address))
 920            {
 82921                foreach (var excludedSubnet in _excludedSubnets)
 922                {
 4923                    if (excludedSubnet.Contains(address))
 924                    {
 2925                        return false;
 926                    }
 927                }
 928
 36929                return true;
 930            }
 931        }
 932
 34933        return false;
 38934    }
 935
 936    /// <summary>
 937    /// Attempts to match the source against the published server URL overrides.
 938    /// </summary>
 939    /// <param name="source">IP source address to use.</param>
 940    /// <param name="isInExternalSubnet">True if the source is in an external subnet.</param>
 941    /// <param name="bindPreference">The published server URL that matches the source address.</param>
 942    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 943    private bool MatchesPublishedServerUrl(IPAddress source, bool isInExternalSubnet, out string bindPreference)
 944    {
 19945        bindPreference = string.Empty;
 19946        int? port = null;
 947
 948        // Only consider subnets including the source IP, preferring specific overrides
 949        List<PublishedServerUriOverride> validPublishedServerUrls;
 19950        if (!isInExternalSubnet)
 951        {
 952            // Only use matching internal subnets
 953            // Prefer more specific (bigger subnet prefix) overrides
 10954            validPublishedServerUrls = _publishedServerUrls.Where(x => x.IsInternalOverride && NetworkUtils.SubnetContai
 10955                .OrderByDescending(x => x.Data.Subnet.PrefixLength)
 10956                .ToList();
 957        }
 958        else
 959        {
 960            // Only use matching external subnets
 961            // Prefer more specific (bigger subnet prefix) overrides
 9962            validPublishedServerUrls = _publishedServerUrls.Where(x => x.IsExternalOverride && NetworkUtils.SubnetContai
 9963                .OrderByDescending(x => x.Data.Subnet.PrefixLength)
 9964                .ToList();
 965        }
 966
 44967        foreach (var data in validPublishedServerUrls)
 968        {
 969            // Get interface matching override subnet
 6970            var intf = _interfaces.OrderBy(x => x.Index).FirstOrDefault(x => NetworkUtils.SubnetContainsAddress(data.Dat
 971
 6972            if (intf?.Address is not null
 6973                || (data.Data.AddressFamily == AddressFamily.InterNetwork && data.Data.Address.Equals(IPAddress.Any))
 6974                || (data.Data.AddressFamily == AddressFamily.InterNetworkV6 && data.Data.Address.Equals(IPAddress.IPv6An
 975            {
 976                // If matching interface is found, use override
 6977                bindPreference = data.OverrideUri;
 6978                break;
 979            }
 980        }
 981
 19982        if (string.IsNullOrEmpty(bindPreference))
 983        {
 13984            _logger.LogDebug("{Source}: No matching bind address override found", source);
 13985            return false;
 986        }
 987
 988        // Handle override specifying port
 6989        var parts = bindPreference.Split(':');
 6990        if (parts.Length > 1)
 991        {
 5992            if (int.TryParse(parts[1], out int p))
 993            {
 0994                bindPreference = parts[0];
 0995                port = p;
 0996                _logger.LogDebug("{Source}: Matching bind address override found: {Address}:{Port}", source, bindPrefere
 0997                return true;
 998            }
 999        }
 1000
 61001        _logger.LogDebug("{Source}: Matching bind address override found: {Address}", source, bindPreference);
 1002
 61003        return true;
 1004    }
 1005
 1006    /// <summary>
 1007    /// Attempts to match the source against the user defined bind interfaces.
 1008    /// </summary>
 1009    /// <param name="source">IP source address to use.</param>
 1010    /// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
 1011    /// <param name="result">The result, if a match is found.</param>
 1012    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 1013    private bool MatchesBindInterface(IPAddress source, bool isInExternalSubnet, out string result)
 1014    {
 131015        result = string.Empty;
 1016
 131017        int count = _interfaces.Count;
 131018        if (count == 1 && (_interfaces[0].Address.Equals(IPAddress.Any) || _interfaces[0].Address.Equals(IPAddress.IPv6A
 1019        {
 1020            // Ignore IPAny addresses.
 01021            count = 0;
 1022        }
 1023
 131024        if (count == 0)
 1025        {
 01026            return false;
 1027        }
 1028
 131029        IPAddress? bindAddress = null;
 131030        if (isInExternalSubnet)
 1031        {
 51032            var externalInterfaces = _interfaces.Where(x => !IsInLocalNetwork(x.Address))
 51033                .Where(x => !IsLinkLocalAddress(x.Address))
 51034                .OrderBy(x => x.Index)
 51035                .ToList();
 51036            if (externalInterfaces.Count > 0)
 1037            {
 1038                // Check to see if any of the external bind interfaces are in the same subnet as the source.
 1039                // If none exists, this will select the first external interface if there is one.
 41040                bindAddress = externalInterfaces
 41041                    .OrderByDescending(x => NetworkUtils.SubnetContainsAddress(x.Subnet, source))
 41042                    .ThenByDescending(x => x.Subnet.PrefixLength)
 41043                    .ThenBy(x => x.Index)
 41044                    .Select(x => x.Address)
 41045                    .First();
 1046
 41047                result = NetworkUtils.FormatIPString(bindAddress);
 41048                _logger.LogDebug("{Source}: External request received, matching external bind address found: {Result}", 
 41049                return true;
 1050            }
 1051
 11052            _logger.LogDebug("{Source}: External request received, no matching external bind address found, trying inter
 1053        }
 1054        else
 1055        {
 1056            // Check to see if any of the internal bind interfaces are in the same subnet as the source.
 1057            // If none exists, this will select the first internal interface if there is one.
 81058            bindAddress = _interfaces.Where(x => IsInLocalNetwork(x.Address))
 81059                .OrderByDescending(x => NetworkUtils.SubnetContainsAddress(x.Subnet, source))
 81060                .ThenByDescending(x => x.Subnet.PrefixLength)
 81061                .ThenBy(x => x.Index)
 81062                .Select(x => x.Address)
 81063                .FirstOrDefault();
 1064
 81065            if (bindAddress is not null)
 1066            {
 71067                result = NetworkUtils.FormatIPString(bindAddress);
 71068                _logger.LogDebug("{Source}: Internal request received, matching internal bind address found: {Result}", 
 71069                return true;
 1070            }
 1071        }
 1072
 21073        return false;
 1074    }
 1075
 1076    /// <summary>
 1077    /// Attempts to match the source against external interfaces.
 1078    /// </summary>
 1079    /// <param name="source">IP source address to use.</param>
 1080    /// <param name="result">The result, if a match is found.</param>
 1081    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 1082    private bool MatchesExternalInterface(IPAddress source, out string result)
 1083    {
 1084        // Get the first external interface address that isn't a loopback.
 11085        var extResult = _interfaces
 11086            .Where(p => !IsInLocalNetwork(p.Address))
 11087            .Where(p => p.Address.AddressFamily.Equals(source.AddressFamily))
 11088            .Where(p => !IsLinkLocalAddress(p.Address))
 11089            .OrderBy(x => x.Index).ToArray();
 1090
 1091        // No external interface found
 11092        if (extResult.Length == 0)
 1093        {
 11094            result = string.Empty;
 11095            _logger.LogDebug("{Source}: External request received, but no external interface found. Need to route throug
 11096            return false;
 1097        }
 1098
 1099        // Does the request originate in one of the interface subnets?
 1100        // (For systems with multiple network cards and/or multiple subnets)
 01101        foreach (var intf in extResult)
 1102        {
 01103            if (NetworkUtils.SubnetContainsAddress(intf.Subnet, source))
 1104            {
 01105                result = NetworkUtils.FormatIPString(intf.Address);
 01106                _logger.LogDebug("{Source}: Found external interface with matching subnet, using it as bind address: {Re
 01107                return true;
 1108            }
 1109        }
 1110
 1111        // Fallback to first external interface.
 01112        result = NetworkUtils.FormatIPString(extResult[0].Address);
 01113        _logger.LogDebug("{Source}: Using first external interface as bind address: {Result}", source, result);
 01114        return true;
 1115    }
 1116
 1117    private void PrintNetworkInformation(NetworkConfiguration config, bool debug = true)
 1118    {
 761119        var logLevel = debug ? LogLevel.Debug : LogLevel.Information;
 761120        if (_logger.IsEnabled(logLevel))
 1121        {
 211122            _logger.Log(logLevel, "Defined LAN subnets: {Subnets}", _lanSubnets.Select(s => s.Prefix + "/" + s.PrefixLen
 211123            _logger.Log(logLevel, "Defined LAN exclusions: {Subnets}", _excludedSubnets.Select(s => s.Prefix + "/" + s.P
 211124            _logger.Log(logLevel, "Used LAN subnets: {Subnets}", _lanSubnets.Where(s => !_excludedSubnets.Contains(s)).S
 211125            _logger.Log(logLevel, "Filtered interface addresses: {Addresses}", _interfaces.OrderByDescending(x => x.Addr
 211126            _logger.Log(logLevel, "Bind Addresses {Addresses}", GetAllBindInterfaces(false).OrderByDescending(x => x.Add
 211127            _logger.Log(logLevel, "Remote IP filter is {Type}", config.IsRemoteIPFilterBlacklist ? "Blocklist" : "Allowl
 211128            _logger.Log(logLevel, "Filtered subnets: {Subnets}", _remoteAddressFilter.Select(s => s.Prefix + "/" + s.Pre
 1129        }
 761130    }
 1131}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:21 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Common.Configuration.IConfigurationManager,Microsoft.Extensions.Configuration.IConfiguration,Microsoft.Extensions.Logging.ILogger`1<Jellyfin.Networking.Manager.NetworkManager>)
.cctor()
get_IsIPv4Enabled()
get_IsIPv6Enabled()
get_PublishedServerUrls()
Dispose()
OnNetworkAvailabilityChanged(System.Object,System.Net.NetworkInformation.NetworkAvailabilityEventArgs)
OnNetworkAddressChanged(System.Object,System.EventArgs)
HandleNetworkChange()
OnNetworkChange()
InitializeInterfaces()
InitializeLan(MediaBrowser.Common.Net.NetworkConfiguration)
EnforceBindSettings(MediaBrowser.Common.Net.NetworkConfiguration)
InitializeRemote(MediaBrowser.Common.Net.NetworkConfiguration)
InitializeOverrides(MediaBrowser.Common.Net.NetworkConfiguration)
ConfigurationUpdated(System.Object,MediaBrowser.Common.Configuration.ConfigurationUpdateEventArgs)
UpdateSettings(System.Object)
Dispose(System.Boolean)
TryParseInterface(System.String,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Model.Net.IPData>&)
HasRemoteAccess(System.Net.IPAddress)
GetLoopbacks()
GetAllBindInterfaces(System.Boolean)
GetBindAddress(System.String,System.Nullable`1<System.Int32>&)
GetBindAddress(Microsoft.AspNetCore.Http.HttpRequest,System.Nullable`1<System.Int32>&)
GetBindAddress(System.Net.IPAddress,System.Nullable`1<System.Int32>&,System.Boolean)
GetInternalBindAddresses()
IsInLocalNetwork(System.String)
IsLinkLocalAddress(System.Net.IPAddress)
IsInLocalNetwork(System.Net.IPAddress)
CheckIfLanAndNotExcluded(System.Net.IPAddress)
MatchesPublishedServerUrl(System.Net.IPAddress,System.Boolean,System.String&)
MatchesBindInterface(System.Net.IPAddress,System.Boolean,System.String&)
MatchesExternalInterface(System.Net.IPAddress,System.String&)
PrintNetworkInformation(MediaBrowser.Common.Net.NetworkConfiguration,System.Boolean)