2020-11-21 13:59:14 +01:00
using System ;
using System.Collections.Generic ;
using System.Collections.ObjectModel ;
2021-02-23 18:06:40 +01:00
using System.Diagnostics.CodeAnalysis ;
2020-11-21 13:59:14 +01:00
using System.Globalization ;
using System.Linq ;
using System.Net ;
using System.Net.NetworkInformation ;
using System.Net.Sockets ;
using System.Threading.Tasks ;
using Jellyfin.Networking.Configuration ;
using MediaBrowser.Common.Configuration ;
using MediaBrowser.Common.Net ;
using Microsoft.AspNetCore.Http ;
using Microsoft.Extensions.Logging ;
namespace Jellyfin.Networking.Manager
{
/// <summary>
/// Class to take care of network interface management.
/// Note: The normal collection methods and properties will not work with Collection{IPObject}. <see cref="MediaBrowser.Common.Net.NetworkExtensions"/>.
/// </summary>
public class NetworkManager : INetworkManager , IDisposable
{
/// <summary>
/// Contains the description of the interface along with its index.
/// </summary>
private readonly Dictionary < string , int > _interfaceNames ;
/// <summary>
/// Threading lock for network properties.
/// </summary>
private readonly object _intLock = new object ( ) ;
/// <summary>
/// List of all interface addresses and masks.
/// </summary>
private readonly Collection < IPObject > _interfaceAddresses ;
/// <summary>
/// List of all interface MAC addresses.
/// </summary>
private readonly List < PhysicalAddress > _macAddresses ;
private readonly ILogger < NetworkManager > _logger ;
private readonly IConfigurationManager _configurationManager ;
private readonly object _eventFireLock ;
/// <summary>
/// Holds the bind address overrides.
/// </summary>
private readonly Dictionary < IPNetAddress , string > _publishedServerUrls ;
/// <summary>
/// Used to stop "event-racing conditions".
/// </summary>
private bool _eventfire ;
/// <summary>
/// Unfiltered user defined LAN subnets. (<see cref="NetworkConfiguration.LocalNetworkSubnets"/>)
/// or internal interface network subnets if undefined by user.
/// </summary>
private Collection < IPObject > _lanSubnets ;
/// <summary>
/// User defined list of subnets to excluded from the LAN.
/// </summary>
private Collection < IPObject > _excludedSubnets ;
/// <summary>
/// List of interface addresses to bind the WS.
/// </summary>
private Collection < IPObject > _bindAddresses ;
/// <summary>
/// List of interface addresses to exclude from bind.
/// </summary>
private Collection < IPObject > _bindExclusions ;
/// <summary>
/// Caches list of all internal filtered interface addresses and masks.
/// </summary>
private Collection < IPObject > _internalInterfaces ;
/// <summary>
2020-11-24 06:11:02 +01:00
/// Flag set when no custom LAN has been defined in the configuration.
2020-11-21 13:59:14 +01:00
/// </summary>
private bool _usingPrivateAddresses ;
/// <summary>
/// True if this object is disposed.
/// </summary>
private bool _disposed ;
/// <summary>
/// Initializes a new instance of the <see cref="NetworkManager"/> class.
/// </summary>
/// <param name="configurationManager">IServerConfigurationManager instance.</param>
/// <param name="logger">Logger to use for messages.</param>
#pragma warning disable CS8618 // Non-nullable field is uninitialized. : Values are set in UpdateSettings function. Compiler doesn't yet recognise this.
public NetworkManager ( IConfigurationManager configurationManager , ILogger < NetworkManager > logger )
{
_logger = logger ? ? throw new ArgumentNullException ( nameof ( logger ) ) ;
_configurationManager = configurationManager ? ? throw new ArgumentNullException ( nameof ( configurationManager ) ) ;
_interfaceAddresses = new Collection < IPObject > ( ) ;
_macAddresses = new List < PhysicalAddress > ( ) ;
_interfaceNames = new Dictionary < string , int > ( ) ;
_publishedServerUrls = new Dictionary < IPNetAddress , string > ( ) ;
_eventFireLock = new object ( ) ;
UpdateSettings ( _configurationManager . GetNetworkConfiguration ( ) ) ;
NetworkChange . NetworkAddressChanged + = OnNetworkAddressChanged ;
NetworkChange . NetworkAvailabilityChanged + = OnNetworkAvailabilityChanged ;
_configurationManager . NamedConfigurationUpdated + = ConfigurationUpdated ;
}
#pragma warning restore CS8618 // Non-nullable field is uninitialized.
/// <summary>
/// Event triggered on network changes.
/// </summary>
public event EventHandler ? NetworkChanged ;
/// <summary>
/// Gets or sets a value indicating whether testing is taking place.
/// </summary>
public static string MockNetworkSettings { get ; set ; } = string . Empty ;
/// <summary>
/// Gets or sets a value indicating whether IP6 is enabled.
/// </summary>
public bool IsIP6Enabled { get ; set ; }
/// <summary>
/// Gets or sets a value indicating whether IP4 is enabled.
/// </summary>
public bool IsIP4Enabled { get ; set ; }
/// <inheritdoc/>
public Collection < IPObject > RemoteAddressFilter { get ; private set ; }
/// <summary>
/// Gets a value indicating whether is all IPv6 interfaces are trusted as internal.
/// </summary>
public bool TrustAllIP6Interfaces { get ; internal set ; }
/// <summary>
/// Gets the Published server override list.
/// </summary>
public Dictionary < IPNetAddress , string > PublishedServerUrls = > _publishedServerUrls ;
/// <summary>
/// Creates a new network collection.
/// </summary>
/// <param name="source">Items to assign the collection, or null.</param>
/// <returns>The collection created.</returns>
public static Collection < IPObject > CreateCollection ( IEnumerable < IPObject > ? source = null )
{
var result = new Collection < IPObject > ( ) ;
if ( source ! = null )
{
foreach ( var item in source )
{
2021-03-10 14:28:18 +01:00
result . AddItem ( item , false ) ;
2020-11-21 13:59:14 +01:00
}
}
return result ;
}
/// <inheritdoc/>
public void Dispose ( )
{
Dispose ( true ) ;
GC . SuppressFinalize ( this ) ;
}
/// <inheritdoc/>
public IReadOnlyCollection < PhysicalAddress > GetMacAddresses ( )
{
// Populated in construction - so always has values.
return _macAddresses ;
}
/// <inheritdoc/>
public bool IsGatewayInterface ( IPObject ? addressObj )
{
var address = addressObj ? . Address ? ? IPAddress . None ;
return _internalInterfaces . Any ( i = > i . Address . Equals ( address ) & & i . Tag < 0 ) ;
}
/// <inheritdoc/>
public bool IsGatewayInterface ( IPAddress ? addressObj )
{
return _internalInterfaces . Any ( i = > i . Address . Equals ( addressObj ? ? IPAddress . None ) & & i . Tag < 0 ) ;
}
/// <inheritdoc/>
public Collection < IPObject > GetLoopbacks ( )
{
Collection < IPObject > nc = new Collection < IPObject > ( ) ;
if ( IsIP4Enabled )
{
nc . AddItem ( IPAddress . Loopback ) ;
}
if ( IsIP6Enabled )
{
nc . AddItem ( IPAddress . IPv6Loopback ) ;
}
return nc ;
}
/// <inheritdoc/>
public bool IsExcluded ( IPAddress ip )
{
return _excludedSubnets . ContainsAddress ( ip ) ;
}
/// <inheritdoc/>
public bool IsExcluded ( EndPoint ip )
{
return ip ! = null & & IsExcluded ( ( ( IPEndPoint ) ip ) . Address ) ;
}
/// <inheritdoc/>
2020-11-24 06:11:02 +01:00
public Collection < IPObject > CreateIPCollection ( string [ ] values , bool negated = false )
2020-11-21 13:59:14 +01:00
{
Collection < IPObject > col = new Collection < IPObject > ( ) ;
if ( values = = null )
{
return col ;
}
for ( int a = 0 ; a < values . Length ; a + + )
{
string v = values [ a ] . Trim ( ) ;
try
{
2020-11-24 06:11:02 +01:00
if ( v . StartsWith ( '!' ) )
2020-11-21 13:59:14 +01:00
{
2020-11-24 06:11:02 +01:00
if ( negated )
2020-11-21 13:59:14 +01:00
{
AddToCollection ( col , v [ 1. . ] ) ;
}
}
2020-11-24 06:11:02 +01:00
else if ( ! negated )
2020-11-21 13:59:14 +01:00
{
AddToCollection ( col , v ) ;
}
}
catch ( ArgumentException e )
{
2020-12-02 15:38:52 +01:00
_logger . LogWarning ( e , "Ignoring LAN value {Value}." , v ) ;
2020-11-21 13:59:14 +01:00
}
}
return col ;
}
/// <inheritdoc/>
public Collection < IPObject > GetAllBindInterfaces ( bool individualInterfaces = false )
{
int count = _bindAddresses . Count ;
if ( count = = 0 )
{
if ( _bindExclusions . Count > 0 )
{
// Return all the interfaces except the ones specifically excluded.
2021-03-14 18:30:25 +01:00
return _interfaceAddresses . Exclude ( _bindExclusions , false ) ;
2020-11-21 13:59:14 +01:00
}
if ( individualInterfaces )
{
return new Collection < IPObject > ( _interfaceAddresses ) ;
}
// No bind address and no exclusions, so listen on all interfaces.
Collection < IPObject > result = new Collection < IPObject > ( ) ;
2021-03-02 00:42:04 +01:00
if ( IsIP6Enabled & & IsIP4Enabled )
{
// Kestrel source code shows it uses Sockets.DualMode - so this also covers IPAddress.Any
result . AddItem ( IPAddress . IPv6Any ) ;
}
else if ( IsIP4Enabled )
2020-11-21 13:59:14 +01:00
{
result . AddItem ( IPAddress . Any ) ;
}
2021-03-02 00:42:04 +01:00
else if ( IsIP6Enabled )
2020-11-21 13:59:14 +01:00
{
2021-03-02 00:42:04 +01:00
// Cannot use IPv6Any as Kestrel will bind to IPv4 addresses.
foreach ( var iface in _interfaceAddresses )
{
if ( iface . AddressFamily = = AddressFamily . InterNetworkV6 )
{
result . AddItem ( iface . Address ) ;
}
}
2020-11-21 13:59:14 +01:00
}
return result ;
}
// Remove any excluded bind interfaces.
2021-03-14 18:30:25 +01:00
return _bindAddresses . Exclude ( _bindExclusions , false ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public string GetBindInterface ( string source , out int? port )
{
if ( ! string . IsNullOrEmpty ( source ) & & IPHost . TryParse ( source , out IPHost host ) )
{
return GetBindInterface ( host , out port ) ;
}
return GetBindInterface ( IPHost . None , out port ) ;
}
/// <inheritdoc/>
public string GetBindInterface ( IPAddress source , out int? port )
{
return GetBindInterface ( new IPNetAddress ( source ) , out port ) ;
}
/// <inheritdoc/>
public string GetBindInterface ( HttpRequest source , out int? port )
{
string result ;
if ( source ! = null & & IPHost . TryParse ( source . Host . Host , out IPHost host ) )
{
result = GetBindInterface ( host , out port ) ;
port ? ? = source . Host . Port ;
}
else
{
result = GetBindInterface ( IPNetAddress . None , out port ) ;
port ? ? = source ? . Host . Port ;
}
return result ;
}
/// <inheritdoc/>
public string GetBindInterface ( IPObject source , out int? port )
{
port = null ;
if ( source = = null )
{
throw new ArgumentNullException ( nameof ( source ) ) ;
}
// Do we have a source?
bool haveSource = ! source . Address . Equals ( IPAddress . None ) ;
bool isExternal = false ;
if ( haveSource )
{
if ( ! IsIP6Enabled & & source . AddressFamily = = AddressFamily . InterNetworkV6 )
{
_logger . LogWarning ( "IPv6 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected." ) ;
}
if ( ! IsIP4Enabled & & source . AddressFamily = = AddressFamily . InterNetwork )
{
_logger . LogWarning ( "IPv4 is disabled in Jellyfin, but enabled in the OS. This may affect how the interface is selected." ) ;
}
isExternal = ! IsInLocalNetwork ( source ) ;
if ( MatchesPublishedServerUrl ( source , isExternal , out string res , out port ) )
{
_logger . LogInformation ( "{Source}: Using BindAddress {Address}:{Port}" , source , res , port ) ;
return res ;
}
}
_logger . LogDebug ( "GetBindInterface: Source: {HaveSource}, External: {IsExternal}:" , haveSource , isExternal ) ;
// No preference given, so move on to bind addresses.
if ( MatchesBindInterface ( source , isExternal , out string result ) )
{
return result ;
}
if ( isExternal & & MatchesExternalInterface ( source , out result ) )
{
return result ;
}
// Get the first LAN interface address that isn't a loopback.
2021-03-09 01:07:21 +01:00
var interfaces = CreateCollection (
_interfaceAddresses
2021-03-14 18:30:25 +01:00
. Exclude ( _bindExclusions , false )
2021-03-09 01:07:21 +01:00
. Where ( IsInLocalNetwork )
2021-03-10 14:28:18 +01:00
. OrderBy ( p = > p . Tag ) ) ;
2020-11-21 13:59:14 +01:00
if ( interfaces . Count > 0 )
{
if ( haveSource )
{
2021-03-14 18:30:25 +01:00
foreach ( var intf in interfaces )
{
if ( intf . Address . Equals ( source . Address ) )
{
result = FormatIP6String ( intf . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Has found matching interface. {Result}" , source , result ) ;
return result ;
}
}
2020-11-21 13:59:14 +01:00
// Does the request originate in one of the interface subnets?
// (For systems with multiple internal network cards, and multiple subnets)
foreach ( var intf in interfaces )
{
if ( intf . Contains ( source ) )
{
result = FormatIP6String ( intf . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Has source, matched best internal interface on range. {Result}" , source , result ) ;
return result ;
}
}
}
result = FormatIP6String ( interfaces . First ( ) . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Matched first internal interface. {Result}" , source , result ) ;
return result ;
}
// There isn't any others, so we'll use the loopback.
2021-03-01 22:32:49 +01:00
result = IsIP6Enabled ? "::1" : "127.0.0.1" ;
2020-11-21 13:59:14 +01:00
_logger . LogWarning ( "{Source}: GetBindInterface: Loopback {Result} returned." , source , result ) ;
return result ;
}
/// <inheritdoc/>
public Collection < IPObject > GetInternalBindAddresses ( )
{
int count = _bindAddresses . Count ;
if ( count = = 0 )
{
if ( _bindExclusions . Count > 0 )
{
// Return all the internal interfaces except the ones excluded.
return CreateCollection ( _internalInterfaces . Where ( p = > ! _bindExclusions . ContainsAddress ( p ) ) ) ;
}
// No bind address, so return all internal interfaces.
2021-05-01 18:21:14 +02:00
return CreateCollection ( _internalInterfaces ) ;
2020-11-21 13:59:14 +01:00
}
2021-09-07 19:52:17 +02:00
return new Collection < IPObject > ( _bindAddresses . Where ( a = > IsInLocalNetwork ( a ) ) . ToArray ( ) ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public bool IsInLocalNetwork ( IPObject address )
{
2022-04-04 00:03:54 +02:00
return IsInLocalNetwork ( address . Address ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public bool IsInLocalNetwork ( string address )
{
2022-04-04 00:03:54 +02:00
return IPHost . TryParse ( address , out IPHost ipHost ) & & IsInLocalNetwork ( ipHost ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public bool IsInLocalNetwork ( IPAddress address )
{
if ( address = = null )
{
throw new ArgumentNullException ( nameof ( address ) ) ;
}
2022-04-04 00:03:54 +02:00
if ( address . Equals ( IPAddress . None ) )
{
return false ;
}
2020-11-21 13:59:14 +01:00
// See conversation at https://github.com/jellyfin/jellyfin/pull/3515.
if ( TrustAllIP6Interfaces & & address . AddressFamily = = AddressFamily . InterNetworkV6 )
{
return true ;
}
// As private addresses can be redefined by Configuration.LocalNetworkAddresses
2022-04-04 00:03:54 +02:00
return IPAddress . IsLoopback ( address ) | | ( _lanSubnets . ContainsAddress ( address ) & & ! _excludedSubnets . ContainsAddress ( address ) ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public bool IsPrivateAddressRange ( IPObject address )
{
if ( address = = null )
{
throw new ArgumentNullException ( nameof ( address ) ) ;
}
// See conversation at https://github.com/jellyfin/jellyfin/pull/3515.
if ( TrustAllIP6Interfaces & & address . AddressFamily = = AddressFamily . InterNetworkV6 )
{
return true ;
}
else
{
return address . IsPrivateAddressRange ( ) ;
}
}
/// <inheritdoc/>
public bool IsExcludedInterface ( IPAddress address )
{
return _bindExclusions . ContainsAddress ( address ) ;
}
/// <inheritdoc/>
public Collection < IPObject > GetFilteredLANSubnets ( Collection < IPObject > ? filter = null )
{
if ( filter = = null )
{
2021-03-14 18:30:25 +01:00
return _lanSubnets . Exclude ( _excludedSubnets , true ) . AsNetworks ( ) ;
2020-11-21 13:59:14 +01:00
}
2021-03-14 18:30:25 +01:00
return _lanSubnets . Exclude ( filter , true ) ;
2020-11-21 13:59:14 +01:00
}
/// <inheritdoc/>
public bool IsValidInterfaceAddress ( IPAddress address )
{
return _interfaceAddresses . ContainsAddress ( address ) ;
}
/// <inheritdoc/>
public bool TryParseInterface ( string token , out Collection < IPObject > ? result )
{
result = null ;
if ( string . IsNullOrEmpty ( token ) )
{
return false ;
}
if ( _interfaceNames ! = null & & _interfaceNames . TryGetValue ( token . ToLower ( CultureInfo . InvariantCulture ) , out int index ) )
{
result = new Collection < IPObject > ( ) ;
_logger . LogInformation ( "Interface {Token} used in settings. Using its interface addresses." , token ) ;
// Replace interface tags with the interface IP's.
foreach ( IPNetAddress iface in _interfaceAddresses )
{
if ( Math . Abs ( iface . Tag ) = = index
& & ( ( IsIP4Enabled & & iface . Address . AddressFamily = = AddressFamily . InterNetwork )
| | ( IsIP6Enabled & & iface . Address . AddressFamily = = AddressFamily . InterNetworkV6 ) ) )
{
2021-03-09 01:07:21 +01:00
result . AddItem ( iface , false ) ;
2020-11-21 13:59:14 +01:00
}
}
return true ;
}
return false ;
}
2021-03-12 15:58:04 +01:00
/// <inheritdoc/>
2021-03-11 22:36:58 +01:00
public bool HasRemoteAccess ( IPAddress remoteIp )
{
var config = _configurationManager . GetNetworkConfiguration ( ) ;
if ( config . EnableRemoteAccess )
{
// Comma separated list of IP addresses or IP/netmask entries for networks that will be allowed to connect remotely.
// If left blank, all remote addresses will be allowed.
if ( RemoteAddressFilter . Count > 0 & & ! IsInLocalNetwork ( remoteIp ) )
{
// remoteAddressFilter is a whitelist or blacklist.
2021-03-11 23:46:07 +01:00
return RemoteAddressFilter . ContainsAddress ( remoteIp ) = = ! config . IsRemoteIPFilterBlacklist ;
2021-03-11 22:36:58 +01:00
}
}
else if ( ! IsInLocalNetwork ( remoteIp ) )
{
// Remote not enabled. So everyone should be LAN.
return false ;
}
return true ;
}
2020-11-21 13:59:14 +01:00
/// <summary>
/// Reloads all settings and re-initialises the instance.
/// </summary>
/// <param name="configuration">The <see cref="NetworkConfiguration"/> to use.</param>
public void UpdateSettings ( object configuration )
{
NetworkConfiguration config = ( NetworkConfiguration ) configuration ? ? throw new ArgumentNullException ( nameof ( configuration ) ) ;
IsIP4Enabled = Socket . OSSupportsIPv4 & & config . EnableIPV4 ;
IsIP6Enabled = Socket . OSSupportsIPv6 & & config . EnableIPV6 ;
if ( ! IsIP6Enabled & & ! IsIP4Enabled )
{
_logger . LogError ( "IPv4 and IPv6 cannot both be disabled." ) ;
IsIP4Enabled = true ;
}
TrustAllIP6Interfaces = config . TrustAllIP6Interfaces ;
if ( string . IsNullOrEmpty ( MockNetworkSettings ) )
{
InitialiseInterfaces ( ) ;
}
else // Used in testing only.
{
// Format is <IPAddress>,<Index>,<Name>: <next interface>. Set index to -ve to simulate a gateway.
2021-01-06 21:39:25 +01:00
var interfaceList = MockNetworkSettings . Split ( '|' ) ;
2020-11-21 13:59:14 +01:00
foreach ( var details in interfaceList )
{
var parts = details . Split ( ',' ) ;
var address = IPNetAddress . Parse ( parts [ 0 ] ) ;
var index = int . Parse ( parts [ 1 ] , CultureInfo . InvariantCulture ) ;
address . Tag = index ;
2021-03-09 01:07:21 +01:00
_interfaceAddresses . AddItem ( address , false ) ;
_interfaceNames [ parts [ 2 ] ] = Math . Abs ( index ) ;
2020-11-21 13:59:14 +01:00
}
}
InitialiseLAN ( config ) ;
InitialiseBind ( config ) ;
InitialiseRemote ( config ) ;
InitialiseOverrides ( config ) ;
}
/// <summary>
/// Protected implementation of Dispose pattern.
/// </summary>
/// <param name="disposing"><c>True</c> to dispose the managed state.</param>
protected virtual void Dispose ( bool disposing )
{
if ( ! _disposed )
{
if ( disposing )
{
_configurationManager . NamedConfigurationUpdated - = ConfigurationUpdated ;
NetworkChange . NetworkAddressChanged - = OnNetworkAddressChanged ;
NetworkChange . NetworkAvailabilityChanged - = OnNetworkAvailabilityChanged ;
}
_disposed = true ;
}
}
/// <summary>
/// Tries to identify the string and return an object of that class.
/// </summary>
/// <param name="addr">String to parse.</param>
/// <param name="result">IPObject to return.</param>
/// <returns><c>true</c> if the value parsed successfully, <c>false</c> otherwise.</returns>
private static bool TryParse ( string addr , out IPObject result )
{
if ( ! string . IsNullOrEmpty ( addr ) )
{
// Is it an IP address
if ( IPNetAddress . TryParse ( addr , out IPNetAddress nw ) )
{
result = nw ;
return true ;
}
if ( IPHost . TryParse ( addr , out IPHost h ) )
{
result = h ;
return true ;
}
}
result = IPNetAddress . None ;
return false ;
}
/// <summary>
/// Converts an IPAddress into a string.
/// Ipv6 addresses are returned in [ ], with their scope removed.
/// </summary>
/// <param name="address">Address to convert.</param>
/// <returns>URI safe conversion of the address.</returns>
private static string FormatIP6String ( IPAddress address )
{
var str = address . ToString ( ) ;
if ( address . AddressFamily = = AddressFamily . InterNetworkV6 )
{
int i = str . IndexOf ( "%" , StringComparison . OrdinalIgnoreCase ) ;
if ( i ! = - 1 )
{
str = str . Substring ( 0 , i ) ;
}
return $"[{str}]" ;
}
return str ;
}
private void ConfigurationUpdated ( object? sender , ConfigurationUpdateEventArgs evt )
{
2021-11-24 13:42:14 +01:00
if ( evt . Key . Equals ( NetworkConfigurationStore . StoreKey , StringComparison . Ordinal ) )
2020-11-21 13:59:14 +01:00
{
UpdateSettings ( ( NetworkConfiguration ) evt . NewConfiguration ) ;
}
}
/// <summary>
/// Checks the string to see if it matches any interface names.
/// </summary>
/// <param name="token">String to check.</param>
2021-02-21 01:41:14 +01:00
/// <param name="index">Interface index numbers that match.</param>
2020-11-21 13:59:14 +01:00
/// <returns><c>true</c> if an interface name matches the token, <c>False</c> otherwise.</returns>
2021-02-24 12:40:50 +01:00
private bool TryGetInterfaces ( string token , [ NotNullWhen ( true ) ] out List < int > ? index )
2020-11-21 13:59:14 +01:00
{
2021-02-21 01:41:14 +01:00
index = null ;
2020-11-21 13:59:14 +01:00
// Is it the name of an interface (windows) eg, Wireless LAN adapter Wireless Network Connection 1.
// Null check required here for automated testing.
if ( _interfaceNames ! = null & & token . Length > 1 )
{
bool partial = token [ ^ 1 ] = = '*' ;
if ( partial )
{
2022-02-14 14:39:33 +01:00
token = token [ . . ^ 1 ] ;
2020-11-21 13:59:14 +01:00
}
foreach ( ( string interfc , int interfcIndex ) in _interfaceNames )
{
if ( ( ! partial & & string . Equals ( interfc , token , StringComparison . OrdinalIgnoreCase ) )
| | ( partial & & interfc . StartsWith ( token , true , CultureInfo . InvariantCulture ) ) )
{
2021-02-23 21:34:42 +01:00
index ? ? = new List < int > ( ) ;
2021-02-21 01:41:14 +01:00
index . Add ( interfcIndex ) ;
2020-11-21 13:59:14 +01:00
}
}
}
2021-02-21 01:41:14 +01:00
return index ! = null ;
2020-11-21 13:59:14 +01:00
}
/// <summary>
2020-11-24 06:11:02 +01:00
/// Parses a string and adds it into the collection, replacing any interface references.
2020-11-21 13:59:14 +01:00
/// </summary>
/// <param name="col"><see cref="Collection{IPObject}"/>Collection.</param>
/// <param name="token">String value to parse.</param>
private void AddToCollection ( Collection < IPObject > col , string token )
{
// Is it the name of an interface (windows) eg, Wireless LAN adapter Wireless Network Connection 1.
// Null check required here for automated testing.
2021-02-27 20:10:53 +01:00
if ( TryGetInterfaces ( token , out var indices ) )
2020-11-21 13:59:14 +01:00
{
_logger . LogInformation ( "Interface {Token} used in settings. Using its interface addresses." , token ) ;
2021-02-21 01:41:14 +01:00
// Replace all the interface tags with the interface IP's.
2020-11-21 13:59:14 +01:00
foreach ( IPNetAddress iface in _interfaceAddresses )
{
2021-02-27 20:10:58 +01:00
if ( indices . Contains ( Math . Abs ( iface . Tag ) )
2020-11-21 13:59:14 +01:00
& & ( ( IsIP4Enabled & & iface . Address . AddressFamily = = AddressFamily . InterNetwork )
| | ( IsIP6Enabled & & iface . Address . AddressFamily = = AddressFamily . InterNetworkV6 ) ) )
{
col . AddItem ( iface ) ;
}
}
}
else if ( TryParse ( token , out IPObject obj ) )
{
2020-11-24 06:11:02 +01:00
// Expand if the ip address is "any".
if ( ( obj . Address . Equals ( IPAddress . Any ) & & IsIP4Enabled )
| | ( obj . Address . Equals ( IPAddress . IPv6Any ) & & IsIP6Enabled ) )
{
foreach ( IPNetAddress iface in _interfaceAddresses )
{
if ( obj . AddressFamily = = iface . AddressFamily )
{
col . AddItem ( iface ) ;
}
}
}
else if ( ! IsIP6Enabled )
2020-11-21 13:59:14 +01:00
{
// Remove IP6 addresses from multi-homed IPHosts.
obj . Remove ( AddressFamily . InterNetworkV6 ) ;
if ( ! obj . IsIP6 ( ) )
{
col . AddItem ( obj ) ;
}
}
else if ( ! IsIP4Enabled )
{
// Remove IP4 addresses from multi-homed IPHosts.
obj . Remove ( AddressFamily . InterNetwork ) ;
if ( obj . IsIP6 ( ) )
{
col . AddItem ( obj ) ;
}
}
else
{
col . AddItem ( obj ) ;
}
}
else
{
2020-12-07 23:06:28 +01:00
_logger . LogDebug ( "Invalid or unknown object {Token}." , token ) ;
2020-11-21 13:59:14 +01:00
}
}
/// <summary>
/// Handler for network change events.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">A <see cref="NetworkAvailabilityEventArgs"/> containing network availability information.</param>
private void OnNetworkAvailabilityChanged ( object? sender , NetworkAvailabilityEventArgs e )
{
_logger . LogDebug ( "Network availability changed." ) ;
OnNetworkChanged ( ) ;
}
/// <summary>
/// Handler for network change events.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">An <see cref="EventArgs"/>.</param>
private void OnNetworkAddressChanged ( object? sender , EventArgs e )
{
_logger . LogDebug ( "Network address change detected." ) ;
OnNetworkChanged ( ) ;
}
/// <summary>
/// Async task that waits for 2 seconds before re-initialising the settings, as typically these events fire multiple times in succession.
/// </summary>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
private async Task OnNetworkChangeAsync ( )
{
try
{
await Task . Delay ( 2000 ) . ConfigureAwait ( false ) ;
InitialiseInterfaces ( ) ;
// Recalculate LAN caches.
InitialiseLAN ( _configurationManager . GetNetworkConfiguration ( ) ) ;
NetworkChanged ? . Invoke ( this , EventArgs . Empty ) ;
}
finally
{
_eventfire = false ;
}
}
/// <summary>
/// Triggers our event, and re-loads interface information.
/// </summary>
private void OnNetworkChanged ( )
{
lock ( _eventFireLock )
{
if ( ! _eventfire )
{
_logger . LogDebug ( "Network Address Change Event." ) ;
// As network events tend to fire one after the other only fire once every second.
_eventfire = true ;
OnNetworkChangeAsync ( ) . GetAwaiter ( ) . GetResult ( ) ;
}
}
}
/// <summary>
/// Parses the user defined overrides into the dictionary object.
/// Overrides are the equivalent of localised publishedServerUrl, enabling
/// different addresses to be advertised over different subnets.
/// format is subnet=ipaddress|host|uri
/// when subnet = 0.0.0.0, any external address matches.
/// </summary>
private void InitialiseOverrides ( NetworkConfiguration config )
{
lock ( _intLock )
{
_publishedServerUrls . Clear ( ) ;
string [ ] overrides = config . PublishedServerUriBySubnet ;
if ( overrides = = null )
{
return ;
}
foreach ( var entry in overrides )
{
var parts = entry . Split ( '=' ) ;
if ( parts . Length ! = 2 )
{
_logger . LogError ( "Unable to parse bind override: {Entry}" , entry ) ;
}
else
{
var replacement = parts [ 1 ] . Trim ( ) ;
2020-11-24 06:11:02 +01:00
if ( string . Equals ( parts [ 0 ] , "all" , StringComparison . OrdinalIgnoreCase ) )
2020-11-21 13:59:14 +01:00
{
_publishedServerUrls [ new IPNetAddress ( IPAddress . Broadcast ) ] = replacement ;
}
else if ( string . Equals ( parts [ 0 ] , "external" , StringComparison . OrdinalIgnoreCase ) )
{
_publishedServerUrls [ new IPNetAddress ( IPAddress . Any ) ] = replacement ;
}
else if ( TryParseInterface ( parts [ 0 ] , out Collection < IPObject > ? addresses ) & & addresses ! = null )
{
foreach ( IPNetAddress na in addresses )
{
_publishedServerUrls [ na ] = replacement ;
}
}
else if ( IPNetAddress . TryParse ( parts [ 0 ] , out IPNetAddress result ) )
{
_publishedServerUrls [ result ] = replacement ;
}
else
{
_logger . LogError ( "Unable to parse bind ip address. {Parts}" , parts [ 1 ] ) ;
}
}
}
}
}
/// <summary>
/// Initialises the network bind addresses.
/// </summary>
private void InitialiseBind ( NetworkConfiguration config )
{
lock ( _intLock )
{
string [ ] lanAddresses = config . LocalNetworkAddresses ;
// Add virtual machine interface names to the list of bind exclusions, so that they are auto-excluded.
if ( config . IgnoreVirtualInterfaces )
{
2021-02-20 23:46:16 +01:00
// each virtual interface name must be pre-pended with the exclusion symbol !
2021-02-21 01:42:06 +01:00
var virtualInterfaceNames = config . VirtualInterfaceNames . Split ( ',' ) . Select ( p = > "!" + p ) . ToArray ( ) ;
2021-02-21 01:41:14 +01:00
if ( lanAddresses . Length > 0 )
{
var newList = new string [ lanAddresses . Length + virtualInterfaceNames . Length ] ;
Array . Copy ( lanAddresses , newList , lanAddresses . Length ) ;
Array . Copy ( virtualInterfaceNames , 0 , newList , lanAddresses . Length , virtualInterfaceNames . Length ) ;
lanAddresses = newList ;
}
else
{
lanAddresses = virtualInterfaceNames ;
}
2020-11-21 13:59:14 +01:00
}
// Read and parse bind addresses and exclusions, removing ones that don't exist.
2021-04-14 11:26:05 +02:00
_bindAddresses = CreateIPCollection ( lanAddresses ) . ThatAreContainedInNetworks ( _interfaceAddresses ) ;
_bindExclusions = CreateIPCollection ( lanAddresses , true ) . ThatAreContainedInNetworks ( _interfaceAddresses ) ;
2020-11-21 13:59:14 +01:00
_logger . LogInformation ( "Using bind addresses: {0}" , _bindAddresses . AsString ( ) ) ;
_logger . LogInformation ( "Using bind exclusions: {0}" , _bindExclusions . AsString ( ) ) ;
}
}
/// <summary>
/// Initialises the remote address values.
/// </summary>
private void InitialiseRemote ( NetworkConfiguration config )
{
lock ( _intLock )
{
RemoteAddressFilter = CreateIPCollection ( config . RemoteIPFilter ) ;
}
}
/// <summary>
/// Initialises internal LAN cache settings.
/// </summary>
private void InitialiseLAN ( NetworkConfiguration config )
{
lock ( _intLock )
{
_logger . LogDebug ( "Refreshing LAN information." ) ;
2020-11-24 06:11:02 +01:00
// Get configuration options.
2020-11-21 13:59:14 +01:00
string [ ] subnets = config . LocalNetworkSubnets ;
// Create lists from user settings.
_lanSubnets = CreateIPCollection ( subnets ) ;
_excludedSubnets = CreateIPCollection ( subnets , true ) . AsNetworks ( ) ;
// If no LAN addresses are specified - all private subnets are deemed to be the LAN
_usingPrivateAddresses = _lanSubnets . Count = = 0 ;
// NOTE: The order of the commands generating the collection in this statement matters.
// Altering the order will cause the collections to be created incorrectly.
if ( _usingPrivateAddresses )
{
_logger . LogDebug ( "Using LAN interface addresses as user provided no LAN details." ) ;
// Internal interfaces must be private and not excluded.
_internalInterfaces = CreateCollection ( _interfaceAddresses . Where ( i = > IsPrivateAddressRange ( i ) & & ! _excludedSubnets . ContainsAddress ( i ) ) ) ;
// Subnets are the same as the calculated internal interface.
_lanSubnets = new Collection < IPObject > ( ) ;
if ( IsIP6Enabled )
{
_lanSubnets . AddItem ( IPNetAddress . Parse ( "fc00::/7" ) ) ; // ULA
_lanSubnets . AddItem ( IPNetAddress . Parse ( "fe80::/10" ) ) ; // Site local
}
if ( IsIP4Enabled )
{
_lanSubnets . AddItem ( IPNetAddress . Parse ( "10.0.0.0/8" ) ) ;
_lanSubnets . AddItem ( IPNetAddress . Parse ( "172.16.0.0/12" ) ) ;
_lanSubnets . AddItem ( IPNetAddress . Parse ( "192.168.0.0/16" ) ) ;
}
}
else
{
// Internal interfaces must be private, not excluded and part of the LocalNetworkSubnet.
2021-04-17 12:19:09 +02:00
_internalInterfaces = CreateCollection ( _interfaceAddresses . Where ( IsInLocalNetwork ) ) ;
2020-11-21 13:59:14 +01:00
}
_logger . LogInformation ( "Defined LAN addresses : {0}" , _lanSubnets . AsString ( ) ) ;
_logger . LogInformation ( "Defined LAN exclusions : {0}" , _excludedSubnets . AsString ( ) ) ;
2021-03-14 18:30:25 +01:00
_logger . LogInformation ( "Using LAN addresses: {0}" , _lanSubnets . Exclude ( _excludedSubnets , true ) . AsNetworks ( ) . AsString ( ) ) ;
2020-11-21 13:59:14 +01:00
}
}
/// <summary>
/// Generate a list of all the interface ip addresses and submasks where that are in the active/unknown state.
/// Generate a list of all active mac addresses that aren't loopback addresses.
/// </summary>
private void InitialiseInterfaces ( )
{
lock ( _intLock )
{
_logger . LogDebug ( "Refreshing interfaces." ) ;
_interfaceNames . Clear ( ) ;
_interfaceAddresses . Clear ( ) ;
_macAddresses . Clear ( ) ;
try
{
IEnumerable < NetworkInterface > nics = NetworkInterface . GetAllNetworkInterfaces ( )
. Where ( i = > i . SupportsMulticast & & i . OperationalStatus = = OperationalStatus . Up ) ;
foreach ( NetworkInterface adapter in nics )
{
try
{
IPInterfaceProperties ipProperties = adapter . GetIPProperties ( ) ;
PhysicalAddress mac = adapter . GetPhysicalAddress ( ) ;
// populate mac list
if ( adapter . NetworkInterfaceType ! = NetworkInterfaceType . Loopback & & mac ! = null & & mac ! = PhysicalAddress . None )
{
_macAddresses . Add ( mac ) ;
}
// populate interface address list
foreach ( UnicastIPAddressInformation info in ipProperties . UnicastAddresses )
{
if ( IsIP4Enabled & & info . Address . AddressFamily = = AddressFamily . InterNetwork )
{
IPNetAddress nw = new IPNetAddress ( info . Address , IPObject . MaskToCidr ( info . IPv4Mask ) )
{
// Keep the number of gateways on this interface, along with its index.
Tag = ipProperties . GetIPv4Properties ( ) . Index
} ;
int tag = nw . Tag ;
if ( ipProperties . GatewayAddresses . Count > 0 & & ! nw . IsLoopback ( ) )
{
// -ve Tags signify the interface has a gateway.
nw . Tag * = - 1 ;
}
2021-03-09 01:07:21 +01:00
_interfaceAddresses . AddItem ( nw , false ) ;
2020-11-21 13:59:14 +01:00
// Store interface name so we can use the name in Collections.
_interfaceNames [ adapter . Description . ToLower ( CultureInfo . InvariantCulture ) ] = tag ;
_interfaceNames [ "eth" + tag . ToString ( CultureInfo . InvariantCulture ) ] = tag ;
}
else if ( IsIP6Enabled & & info . Address . AddressFamily = = AddressFamily . InterNetworkV6 )
{
IPNetAddress nw = new IPNetAddress ( info . Address , ( byte ) info . PrefixLength )
{
// Keep the number of gateways on this interface, along with its index.
Tag = ipProperties . GetIPv6Properties ( ) . Index
} ;
int tag = nw . Tag ;
if ( ipProperties . GatewayAddresses . Count > 0 & & ! nw . IsLoopback ( ) )
{
// -ve Tags signify the interface has a gateway.
nw . Tag * = - 1 ;
}
2021-03-09 01:07:21 +01:00
_interfaceAddresses . AddItem ( nw , false ) ;
2020-11-21 13:59:14 +01:00
// Store interface name so we can use the name in Collections.
_interfaceNames [ adapter . Description . ToLower ( CultureInfo . InvariantCulture ) ] = tag ;
_interfaceNames [ "eth" + tag . ToString ( CultureInfo . InvariantCulture ) ] = tag ;
}
}
}
#pragma warning disable CA1031 // Do not catch general exception types
catch ( Exception ex )
{
// Ignore error, and attempt to continue.
_logger . LogError ( ex , "Error encountered parsing interfaces." ) ;
}
#pragma warning restore CA1031 // Do not catch general exception types
}
2021-04-14 11:26:05 +02:00
}
catch ( Exception ex )
{
_logger . LogError ( ex , "Error in InitialiseInterfaces." ) ;
}
2020-11-21 13:59:14 +01:00
2021-04-14 11:26:05 +02:00
// If for some reason we don't have an interface info, resolve our DNS name.
if ( _interfaceAddresses . Count = = 0 )
{
_logger . LogError ( "No interfaces information available. Resolving DNS name." ) ;
IPHost host = new IPHost ( Dns . GetHostName ( ) ) ;
foreach ( var a in host . GetAddresses ( ) )
{
_interfaceAddresses . AddItem ( a ) ;
}
2020-11-21 13:59:14 +01:00
if ( _interfaceAddresses . Count = = 0 )
{
2021-04-14 11:26:05 +02:00
_logger . LogWarning ( "No interfaces information available. Using loopback." ) ;
2020-11-21 13:59:14 +01:00
}
}
2021-04-14 11:26:05 +02:00
if ( IsIP4Enabled )
2020-11-21 13:59:14 +01:00
{
2021-04-14 11:26:05 +02:00
_interfaceAddresses . AddItem ( IPNetAddress . IP4Loopback ) ;
}
if ( IsIP6Enabled )
{
_interfaceAddresses . AddItem ( IPNetAddress . IP6Loopback ) ;
2020-11-21 13:59:14 +01:00
}
2021-04-14 11:26:05 +02:00
_logger . LogDebug ( "Discovered {0} interfaces." , _interfaceAddresses . Count ) ;
_logger . LogDebug ( "Interfaces addresses : {0}" , _interfaceAddresses . AsString ( ) ) ;
2020-11-21 13:59:14 +01:00
}
}
/// <summary>
/// Attempts to match the source against a user defined bind interface.
/// </summary>
/// <param name="source">IP source address to use.</param>
/// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
/// <param name="bindPreference">The published server url that matches the source address.</param>
/// <param name="port">The resultant port, if one exists.</param>
/// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
private bool MatchesPublishedServerUrl ( IPObject source , bool isInExternalSubnet , out string bindPreference , out int? port )
{
bindPreference = string . Empty ;
port = null ;
// Check for user override.
foreach ( var addr in _publishedServerUrls )
{
// Remaining. Match anything.
if ( addr . Key . Address . Equals ( IPAddress . Broadcast ) )
{
bindPreference = addr . Value ;
break ;
}
else if ( ( addr . Key . Address . Equals ( IPAddress . Any ) | | addr . Key . Address . Equals ( IPAddress . IPv6Any ) ) & & isInExternalSubnet )
{
// External.
bindPreference = addr . Value ;
break ;
}
else if ( addr . Key . Contains ( source ) )
{
// Match ip address.
bindPreference = addr . Value ;
break ;
}
}
if ( string . IsNullOrEmpty ( bindPreference ) )
{
return false ;
}
// Has it got a port defined?
var parts = bindPreference . Split ( ':' ) ;
if ( parts . Length > 1 )
{
if ( int . TryParse ( parts [ 1 ] , out int p ) )
{
bindPreference = parts [ 0 ] ;
port = p ;
}
}
return true ;
}
/// <summary>
/// Attempts to match the source against a user defined bind interface.
/// </summary>
/// <param name="source">IP source address to use.</param>
/// <param name="isInExternalSubnet">True if the source is in the external subnet.</param>
/// <param name="result">The result, if a match is found.</param>
/// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
private bool MatchesBindInterface ( IPObject source , bool isInExternalSubnet , out string result )
{
result = string . Empty ;
2021-03-14 18:30:25 +01:00
var addresses = _bindAddresses . Exclude ( _bindExclusions , false ) ;
2020-11-21 13:59:14 +01:00
int count = addresses . Count ;
if ( count = = 1 & & ( _bindAddresses [ 0 ] . Equals ( IPAddress . Any ) | | _bindAddresses [ 0 ] . Equals ( IPAddress . IPv6Any ) ) )
{
// Ignore IPAny addresses.
count = 0 ;
}
if ( count ! = 0 )
{
// Check to see if any of the bind interfaces are in the same subnet.
IPAddress ? defaultGateway = null ;
IPAddress ? bindAddress = null ;
if ( isInExternalSubnet )
{
// Find all external bind addresses. Store the default gateway, but check to see if there is a better match first.
foreach ( var addr in addresses . OrderBy ( p = > p . Tag ) )
{
if ( defaultGateway = = null & & ! IsInLocalNetwork ( addr ) )
{
defaultGateway = addr . Address ;
}
if ( bindAddress = = null & & addr . Contains ( source ) )
{
bindAddress = addr . Address ;
}
if ( defaultGateway ! = null & & bindAddress ! = null )
{
break ;
}
}
}
else
{
// Look for the best internal address.
bindAddress = addresses
. Where ( p = > IsInLocalNetwork ( p ) & & ( p . Contains ( source ) | | p . Equals ( IPAddress . None ) ) )
. OrderBy ( p = > p . Tag )
. FirstOrDefault ( ) ? . Address ;
}
if ( bindAddress ! = null )
{
result = FormatIP6String ( bindAddress ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Has source, found a match bind interface subnets. {Result}" , source , result ) ;
return true ;
}
if ( isInExternalSubnet & & defaultGateway ! = null )
{
result = FormatIP6String ( defaultGateway ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Using first user defined external interface. {Result}" , source , result ) ;
return true ;
}
result = FormatIP6String ( addresses [ 0 ] . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Selected first user defined interface. {Result}" , source , result ) ;
if ( isInExternalSubnet )
{
_logger . LogWarning ( "{Source}: External request received, however, only an internal interface bind found." , source ) ;
}
return true ;
}
return false ;
}
/// <summary>
/// Attempts to match the source against an external interface.
/// </summary>
/// <param name="source">IP source address to use.</param>
/// <param name="result">The result, if a match is found.</param>
/// <returns><c>true</c> if a match is found, <c>false</c> otherwise.</returns>
private bool MatchesExternalInterface ( IPObject source , out string result )
{
result = string . Empty ;
// Get the first WAN interface address that isn't a loopback.
var extResult = _interfaceAddresses
2021-03-14 18:30:25 +01:00
. Exclude ( _bindExclusions , false )
2020-11-21 13:59:14 +01:00
. Where ( p = > ! IsInLocalNetwork ( p ) )
. OrderBy ( p = > p . Tag ) ;
if ( extResult . Any ( ) )
{
// Does the request originate in one of the interface subnets?
// (For systems with multiple internal network cards, and multiple subnets)
foreach ( var intf in extResult )
{
if ( ! IsInLocalNetwork ( intf ) & & intf . Contains ( source ) )
{
result = FormatIP6String ( intf . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Selected best external on interface on range. {Result}" , source , result ) ;
return true ;
}
}
result = FormatIP6String ( extResult . First ( ) . Address ) ;
_logger . LogDebug ( "{Source}: GetBindInterface: Selected first external interface. {Result}" , source , result ) ;
return true ;
}
2020-12-05 17:28:14 +01:00
_logger . LogDebug ( "{Source}: External request received, but no WAN interface found. Need to route through internal network." , source ) ;
2020-11-21 13:59:14 +01:00
return false ;
}
}
}