< 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: 366
Uncovered lines: 116
Coverable lines: 482
Total lines: 1183
Line coverage: 75.9%
Branch coverage
67%
Covered branches: 176
Total branches: 262
Branch coverage: 67.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 7/14/2025 - 12:10:16 AM Line coverage: 75.9% (366/482) Branch coverage: 67.1% (176/262) Total lines: 1183 7/14/2025 - 12:10:16 AM Line coverage: 75.9% (366/482) Branch coverage: 67.1% (176/262) Total lines: 1183

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()100%11100%
GetInterfacesCore(...)77.77%251872.5%
InitializeLan(...)90%101095.45%
EnforceBindSettings(...)100%11100%
FilterBindSettings(...)77.27%232288%
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%
ShouldAllowServerAccess(...)100%1212100%
GetLoopbacks()0%7280%
GetAllBindInterfaces(...)100%11100%
GetAllBindInterfaces(...)37.5%361657.14%
GetBindAddress(...)100%22100%
GetBindAddress(...)0%620%
GetBindAddress(...)69.44%663671.42%
GetInternalBindAddresses()100%11100%
IsInLocalNetwork(...)0%2040%
IsLinkLocalAddress(...)50%22100%
IsInLocalNetwork(...)75%8885.71%
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 J2N.Collections.Generic.Extensions;
 11using MediaBrowser.Common.Configuration;
 12using MediaBrowser.Common.Net;
 13using MediaBrowser.Model.Net;
 14using Microsoft.AspNetCore.Http;
 15using Microsoft.Extensions.Configuration;
 16using Microsoft.Extensions.Logging;
 17using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
 18using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
 19using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 20
 21namespace Jellyfin.Networking.Manager;
 22
 23/// <summary>
 24/// Class to take care of network interface management.
 25/// </summary>
 26public class NetworkManager : INetworkManager, IDisposable
 27{
 28    /// <summary>
 29    /// Threading lock for network properties.
 30    /// </summary>
 31    private readonly Lock _initLock;
 32
 33    private readonly ILogger<NetworkManager> _logger;
 34
 35    private readonly IConfigurationManager _configurationManager;
 36
 37    private readonly IConfiguration _startupConfig;
 38
 39    private readonly Lock _networkEventLock;
 40
 41    /// <summary>
 42    /// Holds the published server URLs and the IPs to use them on.
 43    /// </summary>
 44    private IReadOnlyList<PublishedServerUriOverride> _publishedServerUrls;
 45
 46    private IReadOnlyList<IPNetwork> _remoteAddressFilter;
 47
 48    /// <summary>
 49    /// Used to stop "event-racing conditions".
 50    /// </summary>
 51    private bool _eventfire;
 52
 53    /// <summary>
 54    /// Dictionary containing interface addresses and their subnets.
 55    /// </summary>
 56    private List<IPData> _interfaces;
 57
 58    /// <summary>
 59    /// Unfiltered user defined LAN subnets (<see cref="NetworkConfiguration.LocalNetworkSubnets"/>)
 60    /// or internal interface network subnets if undefined by user.
 61    /// </summary>
 62    private IReadOnlyList<IPNetwork> _lanSubnets;
 63
 64    /// <summary>
 65    /// User defined list of subnets to excluded from the LAN.
 66    /// </summary>
 67    private IReadOnlyList<IPNetwork> _excludedSubnets;
 68
 69    /// <summary>
 70    /// True if this object is disposed.
 71    /// </summary>
 72    private bool _disposed;
 73
 74    /// <summary>
 75    /// Initializes a new instance of the <see cref="NetworkManager"/> class.
 76    /// </summary>
 77    /// <param name="configurationManager">The <see cref="IConfigurationManager"/> instance.</param>
 78    /// <param name="startupConfig">The <see cref="IConfiguration"/> instance holding startup parameters.</param>
 79    /// <param name="logger">Logger to use for messages.</param>
 80    public NetworkManager(IConfigurationManager configurationManager, IConfiguration startupConfig, ILogger<NetworkManag
 81    {
 7982        ArgumentNullException.ThrowIfNull(logger);
 7983        ArgumentNullException.ThrowIfNull(configurationManager);
 84
 7985        _logger = logger;
 7986        _configurationManager = configurationManager;
 7987        _startupConfig = startupConfig;
 7988        _initLock = new();
 7989        _interfaces = new List<IPData>();
 7990        _publishedServerUrls = new List<PublishedServerUriOverride>();
 7991        _networkEventLock = new();
 7992        _remoteAddressFilter = new List<IPNetwork>();
 93
 7994        _ = bool.TryParse(startupConfig[DetectNetworkChangeKey], out var detectNetworkChange);
 95
 7996        UpdateSettings(_configurationManager.GetNetworkConfiguration());
 97
 7998        if (detectNetworkChange)
 99        {
 21100            NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
 21101            NetworkChange.NetworkAvailabilityChanged += OnNetworkAvailabilityChanged;
 102        }
 103
 79104        _configurationManager.NamedConfigurationUpdated += ConfigurationUpdated;
 79105    }
 106
 107    /// <summary>
 108    /// Event triggered on network changes.
 109    /// </summary>
 110    public event EventHandler? NetworkChanged;
 111
 112    /// <summary>
 113    /// Gets or sets a value indicating whether testing is taking place.
 114    /// </summary>
 3115    public static string MockNetworkSettings { get; set; } = string.Empty;
 116
 117    /// <summary>
 118    /// Gets a value indicating whether IP4 is enabled.
 119    /// </summary>
 249120    public bool IsIPv4Enabled => _configurationManager.GetNetworkConfiguration().EnableIPv4;
 121
 122    /// <summary>
 123    /// Gets a value indicating whether IP6 is enabled.
 124    /// </summary>
 221125    public bool IsIPv6Enabled => _configurationManager.GetNetworkConfiguration().EnableIPv6;
 126
 127    /// <summary>
 128    /// Gets a value indicating whether is all IPv6 interfaces are trusted as internal.
 129    /// </summary>
 130    public bool TrustAllIPv6Interfaces { get; private set; }
 131
 132    /// <summary>
 133    /// Gets the Published server override list.
 134    /// </summary>
 0135    public IReadOnlyList<PublishedServerUriOverride> PublishedServerUrls => _publishedServerUrls;
 136
 137    /// <inheritdoc/>
 138    public void Dispose()
 139    {
 58140        Dispose(true);
 58141        GC.SuppressFinalize(this);
 58142    }
 143
 144    /// <summary>
 145    /// Handler for network change events.
 146    /// </summary>
 147    /// <param name="sender">Sender.</param>
 148    /// <param name="e">A <see cref="NetworkAvailabilityEventArgs"/> containing network availability information.</param
 149    private void OnNetworkAvailabilityChanged(object? sender, NetworkAvailabilityEventArgs e)
 150    {
 0151        _logger.LogDebug("Network availability changed.");
 0152        HandleNetworkChange();
 0153    }
 154
 155    /// <summary>
 156    /// Handler for network change events.
 157    /// </summary>
 158    /// <param name="sender">Sender.</param>
 159    /// <param name="e">An <see cref="EventArgs"/>.</param>
 160    private void OnNetworkAddressChanged(object? sender, EventArgs e)
 161    {
 0162        _logger.LogDebug("Network address change detected.");
 0163        HandleNetworkChange();
 0164    }
 165
 166    /// <summary>
 167    /// Triggers our event, and re-loads interface information.
 168    /// </summary>
 169    private void HandleNetworkChange()
 0170    {
 171        lock (_networkEventLock)
 172        {
 0173            if (!_eventfire)
 174            {
 175                // As network events tend to fire one after the other only fire once every second.
 0176                _eventfire = true;
 0177                OnNetworkChange();
 178            }
 0179        }
 0180    }
 181
 182    /// <summary>
 183    /// Waits for 2 seconds before re-initialising the settings, as typically these events fire multiple times in succes
 184    /// </summary>
 185    private void OnNetworkChange()
 186    {
 187        try
 188        {
 0189            Thread.Sleep(2000);
 0190            var networkConfig = _configurationManager.GetNetworkConfiguration();
 0191            if (IsIPv6Enabled && !Socket.OSSupportsIPv6)
 192            {
 0193                UpdateSettings(networkConfig);
 194            }
 195            else
 196            {
 0197                InitializeInterfaces();
 0198                InitializeLan(networkConfig);
 0199                EnforceBindSettings(networkConfig);
 200            }
 201
 0202            PrintNetworkInformation(networkConfig);
 0203            NetworkChanged?.Invoke(this, EventArgs.Empty);
 0204        }
 205        finally
 206        {
 0207            _eventfire = false;
 0208        }
 0209    }
 210
 211    /// <summary>
 212    /// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
 213    /// </summary>
 214    private void InitializeInterfaces()
 34215    {
 216        lock (_initLock)
 217        {
 34218            _interfaces = GetInterfacesCore(_logger, IsIPv4Enabled, IsIPv6Enabled).ToList();
 34219        }
 34220    }
 221
 222    /// <summary>
 223    /// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
 224    /// </summary>
 225    /// <param name="logger">The logger.</param>
 226    /// <param name="isIPv4Enabled">If true evaluates IPV4 type ip addresses.</param>
 227    /// <param name="isIPv6Enabled">If true evaluates IPV6 type ip addresses.</param>
 228    /// <returns>A list of all locally known up addresses and submasks that are to be considered usable.</returns>
 229    public static IReadOnlyList<IPData> GetInterfacesCore(ILogger logger, bool isIPv4Enabled, bool isIPv6Enabled)
 230    {
 34231        logger.LogDebug("Refreshing interfaces.");
 232
 34233        var interfaces = new List<IPData>();
 234
 235        try
 236        {
 34237            var nics = NetworkInterface.GetAllNetworkInterfaces()
 34238                .Where(i => i.OperationalStatus == OperationalStatus.Up);
 239
 204240            foreach (NetworkInterface adapter in nics)
 241            {
 242                try
 243                {
 68244                    var ipProperties = adapter.GetIPProperties();
 245
 246                    // Populate interface list
 408247                    foreach (var info in ipProperties.UnicastAddresses)
 248                    {
 136249                        if (isIPv4Enabled && info.Address.AddressFamily == AddressFamily.InterNetwork)
 250                        {
 68251                            var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLength
 68252                            {
 68253                                Index = ipProperties.GetIPv4Properties().Index,
 68254                                Name = adapter.Name,
 68255                                SupportsMulticast = adapter.SupportsMulticast
 68256                            };
 257
 68258                            interfaces.Add(interfaceObject);
 259                        }
 68260                        else if (isIPv6Enabled && info.Address.AddressFamily == AddressFamily.InterNetworkV6)
 261                        {
 14262                            var interfaceObject = new IPData(info.Address, new IPNetwork(info.Address, info.PrefixLength
 14263                            {
 14264                                Index = ipProperties.GetIPv6Properties().Index,
 14265                                Name = adapter.Name,
 14266                                SupportsMulticast = adapter.SupportsMulticast
 14267                            };
 268
 14269                            interfaces.Add(interfaceObject);
 270                        }
 271                    }
 68272                }
 0273                catch (Exception ex)
 274                {
 275                    // Ignore error, and attempt to continue.
 0276                    logger.LogError(ex, "Error encountered parsing interfaces.");
 0277                }
 278            }
 34279        }
 0280        catch (Exception ex)
 281        {
 0282            logger.LogError(ex, "Error obtaining interfaces.");
 0283        }
 284
 285        // If no interfaces are found, fallback to loopback interfaces.
 34286        if (interfaces.Count == 0)
 287        {
 0288            logger.LogWarning("No interface information available. Using loopback interface(s).");
 289
 0290            if (isIPv4Enabled)
 291            {
 0292                interfaces.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 293            }
 294
 0295            if (isIPv6Enabled)
 296            {
 0297                interfaces.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 298            }
 299        }
 300
 34301        logger.LogDebug("Discovered {NumberOfInterfaces} interfaces.", interfaces.Count);
 34302        logger.LogDebug("Interfaces addresses: {Addresses}", interfaces.OrderByDescending(s => s.AddressFamily == Addres
 34303        return interfaces;
 304    }
 305
 306    /// <summary>
 307    /// Initializes internal LAN cache.
 308    /// </summary>
 309    [MemberNotNull(nameof(_lanSubnets), nameof(_excludedSubnets))]
 310    private void InitializeLan(NetworkConfiguration config)
 79311    {
 312        lock (_initLock)
 313        {
 79314            _logger.LogDebug("Refreshing LAN information.");
 315
 316            // Get configuration options
 79317            var subnets = config.LocalNetworkSubnets;
 318
 319            // If no LAN addresses are specified, all private subnets and Loopback are deemed to be the LAN
 79320            if (!NetworkUtils.TryParseToSubnets(subnets, out var lanSubnets, false) || lanSubnets.Count == 0)
 321            {
 45322                _logger.LogDebug("Using LAN interface addresses as user provided no LAN details.");
 323
 45324                var fallbackLanSubnets = new List<IPNetwork>();
 45325                if (IsIPv6Enabled)
 326                {
 7327                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4291Loopback); // RFC 4291 (Loopback)
 7328                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4291SiteLocal); // RFC 4291 (Site local)
 7329                    fallbackLanSubnets.Add(NetworkConstants.IPv6RFC4193UniqueLocal); // RFC 4193 (Unique local)
 330                }
 331
 45332                if (IsIPv4Enabled)
 333                {
 45334                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC5735Loopback); // RFC 5735 (Loopback)
 45335                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassA); // RFC 1918 (private Class A)
 45336                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassB); // RFC 1918 (private Class B)
 45337                    fallbackLanSubnets.Add(NetworkConstants.IPv4RFC1918PrivateClassC); // RFC 1918 (private Class C)
 338                }
 339
 45340                _lanSubnets = fallbackLanSubnets;
 341            }
 342            else
 343            {
 34344                _lanSubnets = lanSubnets;
 345            }
 346
 79347            _excludedSubnets = NetworkUtils.TryParseToSubnets(subnets, out var excludedSubnets, true)
 79348                ? excludedSubnets
 79349                : new List<IPNetwork>();
 79350        }
 79351    }
 352
 353    /// <summary>
 354    /// Enforce bind addresses and exclusions on available interfaces.
 355    /// </summary>
 356    private void EnforceBindSettings(NetworkConfiguration config)
 79357    {
 358        lock (_initLock)
 359        {
 79360           _interfaces = FilterBindSettings(config, _interfaces, IsIPv4Enabled, IsIPv6Enabled).ToList();
 79361        }
 79362    }
 363
 364    /// <summary>
 365    /// Filteres a list of bind addresses and exclusions on available interfaces.
 366    /// </summary>
 367    /// <param name="config">The network config to be filtered by.</param>
 368    /// <param name="interfaces">A list of possible interfaces to be filtered.</param>
 369    /// <param name="isIPv4Enabled">If true evaluates IPV4 type ip addresses.</param>
 370    /// <param name="isIPv6Enabled">If true evaluates IPV6 type ip addresses.</param>
 371    /// <returns>A list of all locally known up addresses and submasks that are to be considered usable.</returns>
 372    public static IReadOnlyList<IPData> FilterBindSettings(NetworkConfiguration config, IList<IPData> interfaces, bool i
 373    {
 374        // Respect explicit bind addresses
 79375        var localNetworkAddresses = config.LocalNetworkAddresses;
 79376        if (localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]))
 377        {
 12378            var bindAddresses = localNetworkAddresses.Select(p => NetworkUtils.TryParseToSubnet(p, out var network)
 12379                    ? network.Prefix
 12380                    : (interfaces.Where(x => x.Name.Equals(p, StringComparison.OrdinalIgnoreCase))
 12381                        .Select(x => x.Address)
 12382                        .FirstOrDefault() ?? IPAddress.None))
 12383                .Where(x => x != IPAddress.None)
 12384                .ToHashSet();
 12385            interfaces = interfaces.Where(x => bindAddresses.Contains(x.Address)).ToList();
 386
 12387            if (bindAddresses.Contains(IPAddress.Loopback) && !interfaces.Any(i => i.Address.Equals(IPAddress.Loopback))
 388            {
 0389                interfaces.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 390            }
 391
 12392            if (bindAddresses.Contains(IPAddress.IPv6Loopback) && !interfaces.Any(i => i.Address.Equals(IPAddress.IPv6Lo
 393            {
 0394                interfaces.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 395            }
 396        }
 397
 398        // Remove all interfaces matching any virtual machine interface prefix
 79399        if (config.IgnoreVirtualInterfaces)
 400        {
 401            // Remove potentially existing * and split config string into prefixes
 79402            var virtualInterfacePrefixes = config.VirtualInterfaceNames
 79403                .Select(i => i.Replace("*", string.Empty, StringComparison.OrdinalIgnoreCase));
 404
 405            // Check all interfaces for matches against the prefixes and remove them
 79406            if (interfaces.Count > 0)
 407            {
 316408                foreach (var virtualInterfacePrefix in virtualInterfacePrefixes)
 409                {
 79410                    interfaces.RemoveAll(x => x.Name.StartsWith(virtualInterfacePrefix, StringComparison.OrdinalIgnoreCa
 411                }
 412            }
 413        }
 414
 415        // Remove all IPv4 interfaces if IPv4 is disabled
 79416        if (!isIPv4Enabled)
 417        {
 0418            interfaces.RemoveAll(x => x.AddressFamily == AddressFamily.InterNetwork);
 419        }
 420
 421        // Remove all IPv6 interfaces if IPv6 is disabled
 79422        if (!isIPv6Enabled)
 423        {
 55424            interfaces.RemoveAll(x => x.AddressFamily == AddressFamily.InterNetworkV6);
 425        }
 426
 427        // Users may have complex networking configuration that multiple interfaces sharing the same IP address
 428        // Only return one IP for binding, and let the OS handle the rest
 79429        return interfaces.DistinctBy(iface => iface.Address).ToList();
 430    }
 431
 432    /// <summary>
 433    /// Initializes the remote address values.
 434    /// </summary>
 435    private void InitializeRemote(NetworkConfiguration config)
 79436    {
 437        lock (_initLock)
 438        {
 439            // Parse config values into filter collection
 79440            var remoteIPFilter = config.RemoteIPFilter;
 79441            if (remoteIPFilter.Length != 0 && !string.IsNullOrWhiteSpace(remoteIPFilter[0]))
 442            {
 443                // Parse all IPs with netmask to a subnet
 6444                var remoteAddressFilter = new List<IPNetwork>();
 6445                var remoteFilteredSubnets = remoteIPFilter.Where(x => x.Contains('/', StringComparison.OrdinalIgnoreCase
 6446                if (NetworkUtils.TryParseToSubnets(remoteFilteredSubnets, out var remoteAddressFilterResult, false))
 447                {
 0448                    remoteAddressFilter = remoteAddressFilterResult.ToList();
 449                }
 450
 451                // Parse everything else as an IP and construct subnet with a single IP
 6452                var remoteFilteredIPs = remoteIPFilter.Where(x => !x.Contains('/', StringComparison.OrdinalIgnoreCase));
 28453                foreach (var ip in remoteFilteredIPs)
 454                {
 8455                    if (IPAddress.TryParse(ip, out var ipp))
 456                    {
 8457                        remoteAddressFilter.Add(new IPNetwork(ipp, ipp.AddressFamily == AddressFamily.InterNetwork ? Net
 458                    }
 459                }
 460
 6461                _remoteAddressFilter = remoteAddressFilter;
 462            }
 79463        }
 79464    }
 465
 466    /// <summary>
 467    /// Parses the user defined overrides into the dictionary object.
 468    /// Overrides are the equivalent of localised publishedServerUrl, enabling
 469    /// different addresses to be advertised over different subnets.
 470    /// format is subnet=ipaddress|host|uri
 471    /// when subnet = 0.0.0.0, any external address matches.
 472    /// </summary>
 473    private void InitializeOverrides(NetworkConfiguration config)
 79474    {
 475        lock (_initLock)
 476        {
 79477            var publishedServerUrls = new List<PublishedServerUriOverride>();
 478
 479            // Prefer startup configuration.
 79480            var startupOverrideKey = _startupConfig[AddressOverrideKey];
 79481            if (!string.IsNullOrEmpty(startupOverrideKey))
 482            {
 0483                publishedServerUrls.Add(
 0484                    new PublishedServerUriOverride(
 0485                        new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 0486                        startupOverrideKey,
 0487                        true,
 0488                        true));
 0489                publishedServerUrls.Add(
 0490                    new PublishedServerUriOverride(
 0491                        new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 0492                        startupOverrideKey,
 0493                        true,
 0494                        true));
 0495                _publishedServerUrls = publishedServerUrls;
 0496                return;
 497            }
 498
 79499            var overrides = config.PublishedServerUriBySubnet;
 172500            foreach (var entry in overrides)
 501            {
 8502                var parts = entry.Split('=');
 8503                if (parts.Length != 2)
 504                {
 0505                    _logger.LogError("Unable to parse bind override: {Entry}", entry);
 0506                    return;
 507                }
 508
 8509                var replacement = parts[1].Trim();
 8510                var identifier = parts[0];
 8511                if (string.Equals(identifier, "all", StringComparison.OrdinalIgnoreCase))
 512                {
 513                    // Drop any other overrides in case an "all" override exists
 2514                    publishedServerUrls.Clear();
 2515                    publishedServerUrls.Add(
 2516                        new PublishedServerUriOverride(
 2517                            new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 2518                            replacement,
 2519                            true,
 2520                            true));
 2521                    publishedServerUrls.Add(
 2522                        new PublishedServerUriOverride(
 2523                            new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 2524                            replacement,
 2525                            true,
 2526                            true));
 2527                    break;
 528                }
 6529                else if (string.Equals(identifier, "external", StringComparison.OrdinalIgnoreCase))
 530                {
 4531                    publishedServerUrls.Add(
 4532                        new PublishedServerUriOverride(
 4533                            new IPData(IPAddress.Any, NetworkConstants.IPv4Any),
 4534                            replacement,
 4535                            false,
 4536                            true));
 4537                    publishedServerUrls.Add(
 4538                        new PublishedServerUriOverride(
 4539                            new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any),
 4540                            replacement,
 4541                            false,
 4542                            true));
 543                }
 2544                else if (string.Equals(identifier, "internal", StringComparison.OrdinalIgnoreCase))
 545                {
 0546                    foreach (var lan in _lanSubnets)
 547                    {
 0548                        var lanPrefix = lan.Prefix;
 0549                        publishedServerUrls.Add(
 0550                            new PublishedServerUriOverride(
 0551                                new IPData(lanPrefix, new IPNetwork(lanPrefix, lan.PrefixLength)),
 0552                                replacement,
 0553                                true,
 0554                                false));
 555                    }
 556                }
 2557                else if (NetworkUtils.TryParseToSubnet(identifier, out var result) && result is not null)
 558                {
 1559                    var data = new IPData(result.Prefix, result);
 1560                    publishedServerUrls.Add(
 1561                        new PublishedServerUriOverride(
 1562                            data,
 1563                            replacement,
 1564                            true,
 1565                            true));
 566                }
 1567                else if (TryParseInterface(identifier, out var ifaces))
 568                {
 4569                    foreach (var iface in ifaces)
 570                    {
 1571                        publishedServerUrls.Add(
 1572                            new PublishedServerUriOverride(
 1573                                iface,
 1574                                replacement,
 1575                                true,
 1576                                true));
 577                    }
 578                }
 579                else
 580                {
 0581                    _logger.LogError("Unable to parse bind override: {Entry}", entry);
 582                }
 583            }
 584
 79585            _publishedServerUrls = publishedServerUrls;
 79586        }
 79587    }
 588
 589    private void ConfigurationUpdated(object? sender, ConfigurationUpdateEventArgs evt)
 590    {
 22591        if (evt.Key.Equals(NetworkConfigurationStore.StoreKey, StringComparison.Ordinal))
 592        {
 0593            UpdateSettings((NetworkConfiguration)evt.NewConfiguration);
 594        }
 22595    }
 596
 597    /// <summary>
 598    /// Reloads all settings and re-Initializes the instance.
 599    /// </summary>
 600    /// <param name="configuration">The <see cref="NetworkConfiguration"/> to use.</param>
 601    [MemberNotNull(nameof(_lanSubnets), nameof(_excludedSubnets))]
 602    public void UpdateSettings(object configuration)
 603    {
 79604        ArgumentNullException.ThrowIfNull(configuration);
 605
 79606        var config = (NetworkConfiguration)configuration;
 79607        HappyEyeballs.HttpClientExtension.UseIPv6 = config.EnableIPv6;
 608
 79609        InitializeLan(config);
 79610        InitializeRemote(config);
 611
 79612        if (string.IsNullOrEmpty(MockNetworkSettings))
 613        {
 34614            InitializeInterfaces();
 615        }
 616        else // Used in testing only.
 617        {
 618            // Format is <IPAddress>,<Index>,<Name>: <next interface>. Set index to -ve to simulate a gateway.
 45619            var interfaceList = MockNetworkSettings.Split('|');
 45620            var interfaces = new List<IPData>();
 272621            foreach (var details in interfaceList)
 622            {
 91623                var parts = details.Split(',');
 91624                if (NetworkUtils.TryParseToSubnet(parts[0], out var subnet))
 625                {
 91626                    var address = subnet.Prefix;
 91627                    var index = int.Parse(parts[1], CultureInfo.InvariantCulture);
 91628                    if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.In
 629                    {
 91630                        var data = new IPData(address, subnet, parts[2])
 91631                        {
 91632                            Index = index
 91633                        };
 91634                        interfaces.Add(data);
 635                    }
 636                }
 637                else
 638                {
 0639                    _logger.LogWarning("Could not parse mock interface settings: {Part}", details);
 640                }
 641            }
 642
 45643            _interfaces = interfaces;
 644        }
 645
 79646        EnforceBindSettings(config);
 79647        InitializeOverrides(config);
 648
 79649        PrintNetworkInformation(config, false);
 79650    }
 651
 652    /// <summary>
 653    /// Protected implementation of Dispose pattern.
 654    /// </summary>
 655    /// <param name="disposing"><c>True</c> to dispose the managed state.</param>
 656    protected virtual void Dispose(bool disposing)
 657    {
 58658        if (!_disposed)
 659        {
 58660            if (disposing)
 661            {
 58662                _configurationManager.NamedConfigurationUpdated -= ConfigurationUpdated;
 58663                NetworkChange.NetworkAddressChanged -= OnNetworkAddressChanged;
 58664                NetworkChange.NetworkAvailabilityChanged -= OnNetworkAvailabilityChanged;
 665            }
 666
 58667            _disposed = true;
 668        }
 58669    }
 670
 671    /// <inheritdoc/>
 672    public bool TryParseInterface(string intf, [NotNullWhen(true)] out IReadOnlyList<IPData>? result)
 673    {
 15674        if (string.IsNullOrEmpty(intf)
 15675            || _interfaces is null
 15676            || _interfaces.Count == 0)
 677        {
 0678            result = null;
 0679            return false;
 680        }
 681
 682        // Match all interfaces starting with names starting with token
 15683        result = _interfaces
 15684            .Where(i => i.Name.Equals(intf, StringComparison.OrdinalIgnoreCase)
 15685                        && ((IsIPv4Enabled && i.Address.AddressFamily == AddressFamily.InterNetwork)
 15686                            || (IsIPv6Enabled && i.Address.AddressFamily == AddressFamily.InterNetworkV6)))
 15687            .OrderBy(x => x.Index)
 15688            .ToArray();
 15689        return result.Count > 0;
 690    }
 691
 692    /// <inheritdoc/>
 693    public RemoteAccessPolicyResult ShouldAllowServerAccess(IPAddress remoteIP)
 694    {
 9695        var config = _configurationManager.GetNetworkConfiguration();
 9696        if (IsInLocalNetwork(remoteIP))
 697        {
 1698            return RemoteAccessPolicyResult.Allow;
 699        }
 700
 8701        if (!config.EnableRemoteAccess)
 702        {
 703            // Remote not enabled. So everyone should be LAN.
 2704            return RemoteAccessPolicyResult.RejectDueToRemoteAccessDisabled;
 705        }
 706
 6707        if (!_remoteAddressFilter.Any())
 708        {
 709            // No filter on remote addresses, allow any of them.
 2710            return RemoteAccessPolicyResult.Allow;
 711        }
 712
 713        // Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remot
 714        // If left blank, all remote addresses will be allowed.
 715
 716        // remoteAddressFilter is a whitelist or blacklist.
 4717        var anyMatches = _remoteAddressFilter.Any(remoteNetwork => NetworkUtils.SubnetContainsAddress(remoteNetwork, rem
 4718        if (config.IsRemoteIPFilterBlacklist)
 719        {
 2720            return anyMatches
 2721                ? RemoteAccessPolicyResult.RejectDueToIPBlocklist
 2722                : RemoteAccessPolicyResult.Allow;
 723        }
 724
 725        // Allow-list
 2726        return anyMatches
 2727            ? RemoteAccessPolicyResult.Allow
 2728            : RemoteAccessPolicyResult.RejectDueToNotAllowlistedRemoteIP;
 729    }
 730
 731    /// <inheritdoc/>
 732    public IReadOnlyList<IPData> GetLoopbacks()
 733    {
 0734        if (!IsIPv4Enabled && !IsIPv6Enabled)
 735        {
 0736            return Array.Empty<IPData>();
 737        }
 738
 0739        var loopbackNetworks = new List<IPData>();
 0740        if (IsIPv4Enabled)
 741        {
 0742            loopbackNetworks.Add(new IPData(IPAddress.Loopback, NetworkConstants.IPv4RFC5735Loopback, "lo"));
 743        }
 744
 0745        if (IsIPv6Enabled)
 746        {
 0747            loopbackNetworks.Add(new IPData(IPAddress.IPv6Loopback, NetworkConstants.IPv6RFC4291Loopback, "lo"));
 748        }
 749
 0750        return loopbackNetworks;
 751    }
 752
 753    /// <inheritdoc/>
 754    public IReadOnlyList<IPData> GetAllBindInterfaces(bool individualInterfaces = false)
 755    {
 21756        return NetworkManager.GetAllBindInterfaces(individualInterfaces, _configurationManager, _interfaces, IsIPv4Enabl
 757    }
 758
 759    /// <summary>
 760    /// Reads the jellyfin configuration of the configuration manager and produces a list of interfaces that should be b
 761    /// </summary>
 762    /// <param name="individualInterfaces">Defines that only known interfaces should be used.</param>
 763    /// <param name="configurationManager">The ConfigurationManager.</param>
 764    /// <param name="knownInterfaces">The known interfaces that gets returned if possible or instructed.</param>
 765    /// <param name="readIpv4">Include IPV4 type interfaces.</param>
 766    /// <param name="readIpv6">Include IPV6 type interfaces.</param>
 767    /// <returns>A list of ip address of which jellyfin should bind to.</returns>
 768    public static IReadOnlyList<IPData> GetAllBindInterfaces(
 769        bool individualInterfaces,
 770        IConfigurationManager configurationManager,
 771        IReadOnlyList<IPData> knownInterfaces,
 772        bool readIpv4,
 773        bool readIpv6)
 774    {
 21775        var config = configurationManager.GetNetworkConfiguration();
 21776        var localNetworkAddresses = config.LocalNetworkAddresses;
 21777        if ((localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]) && knownInterfaces
 778        {
 0779            return knownInterfaces;
 780        }
 781
 782        // No bind address and no exclusions, so listen on all interfaces.
 21783        var result = new List<IPData>();
 21784        if (readIpv4 && readIpv6)
 785        {
 786            // Kestrel source code shows it uses Sockets.DualMode - so this also covers IPAddress.Any by default
 0787            result.Add(new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any));
 788        }
 21789        else if (readIpv4)
 790        {
 21791            result.Add(new IPData(IPAddress.Any, NetworkConstants.IPv4Any));
 792        }
 0793        else if (readIpv6)
 794        {
 795            // Cannot use IPv6Any as Kestrel will bind to IPv4 addresses too.
 0796            foreach (var iface in knownInterfaces)
 797            {
 0798                if (iface.AddressFamily == AddressFamily.InterNetworkV6)
 799                {
 0800                    result.Add(iface);
 801                }
 802            }
 803        }
 804
 21805        return result;
 806    }
 807
 808    /// <inheritdoc/>
 809    public string GetBindAddress(string source, out int? port)
 810    {
 23811        if (!NetworkUtils.TryParseHost(source, out var addresses, IsIPv4Enabled, IsIPv6Enabled))
 812        {
 4813            addresses = Array.Empty<IPAddress>();
 814        }
 815
 23816        var result = GetBindAddress(addresses.FirstOrDefault(), out port);
 23817        return result;
 818    }
 819
 820    /// <inheritdoc/>
 821    public string GetBindAddress(HttpRequest source, out int? port)
 822    {
 0823        var result = GetBindAddress(source.Host.Host, out port);
 0824        port ??= source.Host.Port;
 825
 0826        return result;
 827    }
 828
 829    /// <inheritdoc/>
 830    public string GetBindAddress(IPAddress? source, out int? port, bool skipOverrides = false)
 831    {
 23832        port = null;
 833
 834        string result;
 835
 23836        if (source is not null)
 837        {
 19838            if (IsIPv4Enabled && !IsIPv6Enabled && source.AddressFamily == AddressFamily.InterNetworkV6)
 839            {
 0840                _logger.LogWarning("IPv6 is disabled in Jellyfin, but enabled in the OS. This may affect how the interfa
 841            }
 842
 19843            if (!IsIPv4Enabled && IsIPv6Enabled && source.AddressFamily == AddressFamily.InterNetwork)
 844            {
 0845                _logger.LogWarning("IPv4 is disabled in Jellyfin, but enabled in the OS. This may affect how the interfa
 846            }
 847
 19848            bool isExternal = !IsInLocalNetwork(source);
 19849            _logger.LogDebug("Trying to get bind address for source {Source} - External: {IsExternal}", source, isExtern
 850
 19851            if (!skipOverrides && MatchesPublishedServerUrl(source, isExternal, out result))
 852            {
 6853                return result;
 854            }
 855
 856            // No preference given, so move on to bind addresses.
 13857            if (MatchesBindInterface(source, isExternal, out result))
 858            {
 11859                return result;
 860            }
 861
 2862            if (isExternal && MatchesExternalInterface(source, out result))
 863            {
 0864                return result;
 865            }
 866        }
 867
 868        // Get the first LAN interface address that's not excluded and not a loopback address.
 869        // Get all available interfaces, prefer local interfaces
 6870        var availableInterfaces = _interfaces.Where(x => !IPAddress.IsLoopback(x.Address))
 6871            .OrderByDescending(x => IsInLocalNetwork(x.Address))
 6872            .ThenBy(x => x.Index)
 6873            .ToList();
 874
 6875        if (availableInterfaces.Count == 0)
 876        {
 877            // There isn't any others, so we'll use the loopback.
 0878            result = IsIPv4Enabled && !IsIPv6Enabled ? "127.0.0.1" : "::1";
 0879            _logger.LogWarning("{Source}: Only loopback {Result} returned, using that as bind address.", source, result)
 0880            return result;
 881        }
 882
 883        // If no source address is given, use the preferred (first) interface
 6884        if (source is null)
 885        {
 4886            result = NetworkUtils.FormatIPString(availableInterfaces.First().Address);
 4887            _logger.LogDebug("{Source}: Using first internal interface as bind address: {Result}", source, result);
 4888            return result;
 889        }
 890
 891        // Does the request originate in one of the interface subnets?
 892        // (For systems with multiple internal network cards, and multiple subnets)
 8893        foreach (var intf in availableInterfaces)
 894        {
 2895            if (NetworkUtils.SubnetContainsAddress(intf.Subnet, source))
 896            {
 0897                result = NetworkUtils.FormatIPString(intf.Address);
 0898                _logger.LogDebug("{Source}: Found interface with matching subnet, using it as bind address: {Result}", s
 0899                return result;
 900            }
 901        }
 902
 903        // Fallback to first available interface
 2904        result = NetworkUtils.FormatIPString(availableInterfaces[0].Address);
 2905        _logger.LogDebug("{Source}: No matching interfaces found, using preferred interface as bind address: {Result}", 
 2906        return result;
 0907    }
 908
 909    /// <inheritdoc/>
 910    public IReadOnlyList<IPData> GetInternalBindAddresses()
 911    {
 912        // Select all local bind addresses
 6913        return _interfaces.Where(x => IsInLocalNetwork(x.Address))
 6914            .OrderBy(x => x.Index)
 6915            .ToList();
 916    }
 917
 918    /// <inheritdoc/>
 919    public bool IsInLocalNetwork(string address)
 920    {
 0921        if (NetworkUtils.TryParseToSubnet(address, out var subnet))
 922        {
 0923            return IsInLocalNetwork(subnet.Prefix);
 924        }
 925
 0926        return NetworkUtils.TryParseHost(address, out var addresses, IsIPv4Enabled, IsIPv6Enabled)
 0927               && addresses.Any(IsInLocalNetwork);
 928    }
 929
 930    /// <summary>
 931    ///  Get if the IPAddress is Link-local.
 932    /// </summary>
 933    /// <param name="address">The IP Address.</param>
 934    /// <returns>Bool indicates if the address is link-local.</returns>
 935    public bool IsLinkLocalAddress(IPAddress address)
 936    {
 4937        ArgumentNullException.ThrowIfNull(address);
 4938        return NetworkConstants.IPv4RFC3927LinkLocal.Contains(address) || address.IsIPv6LinkLocal;
 939    }
 940
 941    /// <inheritdoc/>
 942    public bool IsInLocalNetwork(IPAddress address)
 943    {
 162944        ArgumentNullException.ThrowIfNull(address);
 945
 946        // Map IPv6 mapped IPv4 back to IPv4 (happens if Kestrel runs in dual-socket mode)
 162947        if (address.IsIPv4MappedToIPv6)
 948        {
 0949            address = address.MapToIPv4();
 950        }
 951
 162952        if ((TrustAllIPv6Interfaces && address.AddressFamily == AddressFamily.InterNetworkV6)
 162953            || IPAddress.IsLoopback(address))
 954        {
 86955            return true;
 956        }
 957
 958        // As private addresses can be redefined by Configuration.LocalNetworkAddresses
 76959        return CheckIfLanAndNotExcluded(address);
 960    }
 961
 962    /// <summary>
 963    /// Check if the address is in the LAN and not excluded.
 964    /// </summary>
 965    /// <param name="address">The IP address to check. The caller should make sure this is not an IPv4MappedToIPv6 addre
 966    /// <returns>Boolean indicates whether the address is in LAN.</returns>
 967    private bool CheckIfLanAndNotExcluded(IPAddress address)
 968    {
 416969        foreach (var lanSubnet in _lanSubnets)
 970        {
 151971            if (lanSubnet.Contains(address))
 972            {
 82973                foreach (var excludedSubnet in _excludedSubnets)
 974                {
 4975                    if (excludedSubnet.Contains(address))
 976                    {
 2977                        return false;
 978                    }
 979                }
 980
 36981                return true;
 982            }
 983        }
 984
 38985        return false;
 38986    }
 987
 988    /// <summary>
 989    /// Attempts to match the source against the published server URL overrides.
 990    /// </summary>
 991    /// <param name="source">IP source address to use.</param>
 992    /// <param name="isInExternalSubnet">True if the source is in an external subnet.</param>
 993    /// <param name="bindPreference">The published server URL that matches the source address.</param>
 994    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 995    private bool MatchesPublishedServerUrl(IPAddress source, bool isInExternalSubnet, out string bindPreference)
 996    {
 19997        bindPreference = string.Empty;
 19998        int? port = null;
 999
 1000        // Only consider subnets including the source IP, preferring specific overrides
 1001        List<PublishedServerUriOverride> validPublishedServerUrls;
 191002        if (!isInExternalSubnet)
 1003        {
 1004            // Only use matching internal subnets
 1005            // Prefer more specific (bigger subnet prefix) overrides
 101006            validPublishedServerUrls = _publishedServerUrls.Where(x => x.IsInternalOverride && NetworkUtils.SubnetContai
 101007                .OrderByDescending(x => x.Data.Subnet.PrefixLength)
 101008                .ToList();
 1009        }
 1010        else
 1011        {
 1012            // Only use matching external subnets
 1013            // Prefer more specific (bigger subnet prefix) overrides
 91014            validPublishedServerUrls = _publishedServerUrls.Where(x => x.IsExternalOverride && NetworkUtils.SubnetContai
 91015                .OrderByDescending(x => x.Data.Subnet.PrefixLength)
 91016                .ToList();
 1017        }
 1018
 441019        foreach (var data in validPublishedServerUrls)
 1020        {
 1021            // Get interface matching override subnet
 61022            var intf = _interfaces.OrderBy(x => x.Index).FirstOrDefault(x => NetworkUtils.SubnetContainsAddress(data.Dat
 1023
 61024            if (intf?.Address is not null
 61025                || (data.Data.AddressFamily == AddressFamily.InterNetwork && data.Data.Address.Equals(IPAddress.Any))
 61026                || (data.Data.AddressFamily == AddressFamily.InterNetworkV6 && data.Data.Address.Equals(IPAddress.IPv6An
 1027            {
 1028                // If matching interface is found, use override
 61029                bindPreference = data.OverrideUri;
 61030                break;
 1031            }
 1032        }
 1033
 191034        if (string.IsNullOrEmpty(bindPreference))
 1035        {
 131036            _logger.LogDebug("{Source}: No matching bind address override found", source);
 131037            return false;
 1038        }
 1039
 1040        // Handle override specifying port
 61041        var parts = bindPreference.Split(':');
 61042        if (parts.Length > 1)
 1043        {
 51044            if (int.TryParse(parts[1], out int p))
 1045            {
 01046                bindPreference = parts[0];
 01047                port = p;
 01048                _logger.LogDebug("{Source}: Matching bind address override found: {Address}:{Port}", source, bindPrefere
 01049                return true;
 1050            }
 1051        }
 1052
 61053        _logger.LogDebug("{Source}: Matching bind address override found: {Address}", source, bindPreference);
 1054
 61055        return true;
 1056    }
 1057
 1058    /// <summary>
 1059    /// Attempts to match the source against the user defined bind interfaces.
 1060    /// </summary>
 1061    /// <param name="source">IP source address to use.</param>
 1062    /// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
 1063    /// <param name="result">The result, if a match is found.</param>
 1064    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 1065    private bool MatchesBindInterface(IPAddress source, bool isInExternalSubnet, out string result)
 1066    {
 131067        result = string.Empty;
 1068
 131069        int count = _interfaces.Count;
 131070        if (count == 1 && (_interfaces[0].Address.Equals(IPAddress.Any) || _interfaces[0].Address.Equals(IPAddress.IPv6A
 1071        {
 1072            // Ignore IPAny addresses.
 01073            count = 0;
 1074        }
 1075
 131076        if (count == 0)
 1077        {
 01078            return false;
 1079        }
 1080
 131081        IPAddress? bindAddress = null;
 131082        if (isInExternalSubnet)
 1083        {
 51084            var externalInterfaces = _interfaces.Where(x => !IsInLocalNetwork(x.Address))
 51085                .Where(x => !IsLinkLocalAddress(x.Address))
 51086                .OrderBy(x => x.Index)
 51087                .ToList();
 51088            if (externalInterfaces.Count > 0)
 1089            {
 1090                // Check to see if any of the external bind interfaces are in the same subnet as the source.
 1091                // If none exists, this will select the first external interface if there is one.
 41092                bindAddress = externalInterfaces
 41093                    .OrderByDescending(x => NetworkUtils.SubnetContainsAddress(x.Subnet, source))
 41094                    .ThenByDescending(x => x.Subnet.PrefixLength)
 41095                    .ThenBy(x => x.Index)
 41096                    .Select(x => x.Address)
 41097                    .First();
 1098
 41099                result = NetworkUtils.FormatIPString(bindAddress);
 41100                _logger.LogDebug("{Source}: External request received, matching external bind address found: {Result}", 
 41101                return true;
 1102            }
 1103
 11104            _logger.LogDebug("{Source}: External request received, no matching external bind address found, trying inter
 1105        }
 1106        else
 1107        {
 1108            // Check to see if any of the internal bind interfaces are in the same subnet as the source.
 1109            // If none exists, this will select the first internal interface if there is one.
 81110            bindAddress = _interfaces.Where(x => IsInLocalNetwork(x.Address))
 81111                .OrderByDescending(x => NetworkUtils.SubnetContainsAddress(x.Subnet, source))
 81112                .ThenByDescending(x => x.Subnet.PrefixLength)
 81113                .ThenBy(x => x.Index)
 81114                .Select(x => x.Address)
 81115                .FirstOrDefault();
 1116
 81117            if (bindAddress is not null)
 1118            {
 71119                result = NetworkUtils.FormatIPString(bindAddress);
 71120                _logger.LogDebug("{Source}: Internal request received, matching internal bind address found: {Result}", 
 71121                return true;
 1122            }
 1123        }
 1124
 21125        return false;
 1126    }
 1127
 1128    /// <summary>
 1129    /// Attempts to match the source against external interfaces.
 1130    /// </summary>
 1131    /// <param name="source">IP source address to use.</param>
 1132    /// <param name="result">The result, if a match is found.</param>
 1133    /// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
 1134    private bool MatchesExternalInterface(IPAddress source, out string result)
 1135    {
 1136        // Get the first external interface address that isn't a loopback.
 11137        var extResult = _interfaces
 11138            .Where(p => !IsInLocalNetwork(p.Address))
 11139            .Where(p => p.Address.AddressFamily.Equals(source.AddressFamily))
 11140            .Where(p => !IsLinkLocalAddress(p.Address))
 11141            .OrderBy(x => x.Index).ToArray();
 1142
 1143        // No external interface found
 11144        if (extResult.Length == 0)
 1145        {
 11146            result = string.Empty;
 11147            _logger.LogDebug("{Source}: External request received, but no external interface found. Need to route throug
 11148            return false;
 1149        }
 1150
 1151        // Does the request originate in one of the interface subnets?
 1152        // (For systems with multiple network cards and/or multiple subnets)
 01153        foreach (var intf in extResult)
 1154        {
 01155            if (NetworkUtils.SubnetContainsAddress(intf.Subnet, source))
 1156            {
 01157                result = NetworkUtils.FormatIPString(intf.Address);
 01158                _logger.LogDebug("{Source}: Found external interface with matching subnet, using it as bind address: {Re
 01159                return true;
 1160            }
 1161        }
 1162
 1163        // Fallback to first external interface.
 01164        result = NetworkUtils.FormatIPString(extResult[0].Address);
 01165        _logger.LogDebug("{Source}: Using first external interface as bind address: {Result}", source, result);
 01166        return true;
 1167    }
 1168
 1169    private void PrintNetworkInformation(NetworkConfiguration config, bool debug = true)
 1170    {
 791171        var logLevel = debug ? LogLevel.Debug : LogLevel.Information;
 791172        if (_logger.IsEnabled(logLevel))
 1173        {
 211174            _logger.Log(logLevel, "Defined LAN subnets: {Subnets}", _lanSubnets.Select(s => s.Prefix + "/" + s.PrefixLen
 211175            _logger.Log(logLevel, "Defined LAN exclusions: {Subnets}", _excludedSubnets.Select(s => s.Prefix + "/" + s.P
 211176            _logger.Log(logLevel, "Used LAN subnets: {Subnets}", _lanSubnets.Where(s => !_excludedSubnets.Contains(s)).S
 211177            _logger.Log(logLevel, "Filtered interface addresses: {Addresses}", _interfaces.OrderByDescending(x => x.Addr
 211178            _logger.Log(logLevel, "Bind Addresses {Addresses}", GetAllBindInterfaces(false).OrderByDescending(x => x.Add
 211179            _logger.Log(logLevel, "Remote IP filter is {Type}", config.IsRemoteIPFilterBlacklist ? "Blocklist" : "Allowl
 211180            _logger.Log(logLevel, "Filtered subnets: {Subnets}", _remoteAddressFilter.Select(s => s.Prefix + "/" + s.Pre
 1181        }
 791182    }
 1183}
Generated by: ReportGenerator 5.4.17.0
10/26/2025 - 12:11:40 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()
GetInterfacesCore(Microsoft.Extensions.Logging.ILogger,System.Boolean,System.Boolean)
InitializeLan(MediaBrowser.Common.Net.NetworkConfiguration)
EnforceBindSettings(MediaBrowser.Common.Net.NetworkConfiguration)
FilterBindSettings(MediaBrowser.Common.Net.NetworkConfiguration,System.Collections.Generic.IList`1<MediaBrowser.Model.Net.IPData>,System.Boolean,System.Boolean)
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>&)
ShouldAllowServerAccess(System.Net.IPAddress)
GetLoopbacks()
GetAllBindInterfaces(System.Boolean)
GetAllBindInterfaces(System.Boolean,MediaBrowser.Common.Configuration.IConfigurationManager,System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Model.Net.IPData>,System.Boolean,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)