using MediaBrowser.Model.Logging; using System; using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Net; using System.Net.NetworkInformation; using System.Net.Sockets; using System.Threading.Tasks; using MediaBrowser.Model.Extensions; namespace Emby.Common.Implementations.Networking { public abstract class BaseNetworkManager { protected ILogger Logger { get; private set; } private DateTime _lastRefresh; protected BaseNetworkManager(ILogger logger) { Logger = logger; } private List _localIpAddresses; private readonly object _localIpAddressSyncLock = new object(); /// /// Gets the machine's local ip address /// /// IPAddress. public IEnumerable GetLocalIpAddresses() { const int cacheMinutes = 5; lock (_localIpAddressSyncLock) { var forceRefresh = (DateTime.UtcNow - _lastRefresh).TotalMinutes >= cacheMinutes; if (_localIpAddresses == null || forceRefresh) { var addresses = GetLocalIpAddressesInternal().ToList(); _localIpAddresses = addresses; _lastRefresh = DateTime.UtcNow; return addresses; } } return _localIpAddresses; } private IEnumerable GetLocalIpAddressesInternal() { var list = GetIPsDefault() .ToList(); if (list.Count == 0) { list.AddRange(GetLocalIpAddressesFallback().Result); } return list.Where(FilterIpAddress).DistinctBy(i => i.ToString()); } private bool FilterIpAddress(IPAddress address) { var addressString = address.ToString (); if (addressString.StartsWith("169.", StringComparison.OrdinalIgnoreCase)) { return false; } return true; } public bool IsInPrivateAddressSpace(string endpoint) { if (string.Equals(endpoint, "::1", StringComparison.OrdinalIgnoreCase)) { return true; } // Handle ipv4 mapped to ipv6 endpoint = endpoint.Replace("::ffff:", string.Empty); // Private address space: // http://en.wikipedia.org/wiki/Private_network if (endpoint.StartsWith("172.", StringComparison.OrdinalIgnoreCase)) { return Is172AddressPrivate(endpoint); } return endpoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) || endpoint.StartsWith("127.", StringComparison.OrdinalIgnoreCase) || endpoint.StartsWith("10.", StringComparison.OrdinalIgnoreCase) || endpoint.StartsWith("192.168", StringComparison.OrdinalIgnoreCase) || endpoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase); } private bool Is172AddressPrivate(string endpoint) { for (var i = 16; i <= 31; i++) { if (endpoint.StartsWith("172." + i.ToString(CultureInfo.InvariantCulture) + ".", StringComparison.OrdinalIgnoreCase)) { return true; } } return false; } public bool IsInLocalNetwork(string endpoint) { return IsInLocalNetworkInternal(endpoint, true); } public bool IsInLocalNetworkInternal(string endpoint, bool resolveHost) { if (string.IsNullOrWhiteSpace(endpoint)) { throw new ArgumentNullException("endpoint"); } IPAddress address; if (IPAddress.TryParse(endpoint, out address)) { var addressString = address.ToString(); int lengthMatch = 100; if (address.AddressFamily == AddressFamily.InterNetwork) { lengthMatch = 4; if (IsInPrivateAddressSpace(addressString)) { return true; } } else if (address.AddressFamily == AddressFamily.InterNetworkV6) { lengthMatch = 10; if (IsInPrivateAddressSpace(endpoint)) { return true; } } // Should be even be doing this with ipv6? if (addressString.Length >= lengthMatch) { var prefix = addressString.Substring(0, lengthMatch); if (GetLocalIpAddresses().Any(i => i.ToString().StartsWith(prefix, StringComparison.OrdinalIgnoreCase))) { return true; } } } else if (resolveHost) { Uri uri; if (Uri.TryCreate(endpoint, UriKind.RelativeOrAbsolute, out uri)) { try { var host = uri.DnsSafeHost; Logger.Debug("Resolving host {0}", host); address = GetIpAddresses(host).Result.FirstOrDefault(); if (address != null) { Logger.Debug("{0} resolved to {1}", host, address); return IsInLocalNetworkInternal(address.ToString(), false); } } catch (InvalidOperationException) { // Can happen with reverse proxy or IIS url rewriting } catch (Exception ex) { Logger.ErrorException("Error resovling hostname", ex); } } } return false; } private Task GetIpAddresses(string hostName) { return Dns.GetHostAddressesAsync(hostName); } private List GetIPsDefault() { NetworkInterface[] interfaces; try { interfaces = NetworkInterface.GetAllNetworkInterfaces(); } catch (Exception ex) { Logger.ErrorException("Error in GetAllNetworkInterfaces", ex); return new List(); } return interfaces.SelectMany(network => { try { Logger.Debug("Querying interface: {0}. Type: {1}. Status: {2}", network.Name, network.NetworkInterfaceType, network.OperationalStatus); var properties = network.GetIPProperties(); return properties.UnicastAddresses .Where(i => i.IsDnsEligible) .Select(i => i.Address) .Where(i => i.AddressFamily == AddressFamily.InterNetwork) .ToList(); } catch (Exception ex) { Logger.ErrorException("Error querying network interface", ex); return new List(); } }).DistinctBy(i => i.ToString()) .ToList(); } private async Task> GetLocalIpAddressesFallback() { var host = await Dns.GetHostEntryAsync(Dns.GetHostName()).ConfigureAwait(false); // Reverse them because the last one is usually the correct one // It's not fool-proof so ultimately the consumer will have to examine them and decide return host.AddressList .Where(i => i.AddressFamily == AddressFamily.InterNetwork) .Reverse(); } /// /// Gets a random port number that is currently available /// /// System.Int32. public int GetRandomUnusedPort() { var listener = new TcpListener(IPAddress.Any, 0); listener.Start(); var port = ((IPEndPoint)listener.LocalEndpoint).Port; listener.Stop(); return port; } /// /// Returns MAC Address from first Network Card in Computer /// /// [string] MAC Address public string GetMacAddress() { return NetworkInterface.GetAllNetworkInterfaces() .Where(i => i.NetworkInterfaceType != NetworkInterfaceType.Loopback) .Select(i => BitConverter.ToString(i.GetPhysicalAddress().GetAddressBytes())) .FirstOrDefault(); } /// /// Parses the specified endpointstring. /// /// The endpointstring. /// IPEndPoint. public IPEndPoint Parse(string endpointstring) { return Parse(endpointstring, -1).Result; } /// /// Parses the specified endpointstring. /// /// The endpointstring. /// The defaultport. /// IPEndPoint. /// Endpoint descriptor may not be empty. /// private static async Task Parse(string endpointstring, int defaultport) { if (String.IsNullOrEmpty(endpointstring) || endpointstring.Trim().Length == 0) { throw new ArgumentException("Endpoint descriptor may not be empty."); } if (defaultport != -1 && (defaultport < IPEndPoint.MinPort || defaultport > IPEndPoint.MaxPort)) { throw new ArgumentException(String.Format("Invalid default port '{0}'", defaultport)); } string[] values = endpointstring.Split(new char[] { ':' }); IPAddress ipaddy; int port = -1; //check if we have an IPv6 or ports if (values.Length <= 2) // ipv4 or hostname { port = values.Length == 1 ? defaultport : GetPort(values[1]); //try to use the address as IPv4, otherwise get hostname if (!IPAddress.TryParse(values[0], out ipaddy)) ipaddy = await GetIPfromHost(values[0]).ConfigureAwait(false); } else if (values.Length > 2) //ipv6 { //could [a:b:c]:d if (values[0].StartsWith("[") && values[values.Length - 2].EndsWith("]")) { string ipaddressstring = String.Join(":", values.Take(values.Length - 1).ToArray()); ipaddy = IPAddress.Parse(ipaddressstring); port = GetPort(values[values.Length - 1]); } else //[a:b:c] or a:b:c { ipaddy = IPAddress.Parse(endpointstring); port = defaultport; } } else { throw new FormatException(String.Format("Invalid endpoint ipaddress '{0}'", endpointstring)); } if (port == -1) throw new ArgumentException(String.Format("No port specified: '{0}'", endpointstring)); return new IPEndPoint(ipaddy, port); } protected static readonly CultureInfo UsCulture = new CultureInfo("en-US"); /// /// Gets the port. /// /// The p. /// System.Int32. /// private static int GetPort(string p) { int port; if (!Int32.TryParse(p, out port) || port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort) { throw new FormatException(String.Format("Invalid end point port '{0}'", p)); } return port; } /// /// Gets the I pfrom host. /// /// The p. /// IPAddress. /// private static async Task GetIPfromHost(string p) { var hosts = await Dns.GetHostAddressesAsync(p).ConfigureAwait(false); if (hosts == null || hosts.Length == 0) throw new ArgumentException(String.Format("Host not found: {0}", p)); return hosts[0]; } } }