NetworkManager.cs 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Globalization;
  4. using System.Linq;
  5. using System.Net;
  6. using System.Net.NetworkInformation;
  7. using System.Net.Sockets;
  8. using System.Threading.Tasks;
  9. using MediaBrowser.Common.Net;
  10. using MediaBrowser.Model.IO;
  11. using MediaBrowser.Model.Net;
  12. using Microsoft.Extensions.Logging;
  13. namespace Emby.Server.Implementations.Networking
  14. {
  15. public class NetworkManager : INetworkManager
  16. {
  17. private readonly ILogger _logger;
  18. private IPAddress[] _localIpAddresses;
  19. private readonly object _localIpAddressSyncLock = new object();
  20. private readonly object _subnetLookupLock = new object();
  21. private Dictionary<string, List<string>> _subnetLookup = new Dictionary<string, List<string>>(StringComparer.Ordinal);
  22. public NetworkManager(ILogger<NetworkManager> logger)
  23. {
  24. _logger = logger;
  25. NetworkChange.NetworkAddressChanged += OnNetworkAddressChanged;
  26. NetworkChange.NetworkAvailabilityChanged += OnNetworkAvailabilityChanged;
  27. }
  28. public event EventHandler NetworkChanged;
  29. public Func<string[]> LocalSubnetsFn { get; set; }
  30. private void OnNetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
  31. {
  32. _logger.LogDebug("NetworkAvailabilityChanged");
  33. OnNetworkChanged();
  34. }
  35. private void OnNetworkAddressChanged(object sender, EventArgs e)
  36. {
  37. _logger.LogDebug("NetworkAddressChanged");
  38. OnNetworkChanged();
  39. }
  40. private void OnNetworkChanged()
  41. {
  42. lock (_localIpAddressSyncLock)
  43. {
  44. _localIpAddresses = null;
  45. _macAddresses = null;
  46. }
  47. if (NetworkChanged != null)
  48. {
  49. NetworkChanged(this, EventArgs.Empty);
  50. }
  51. }
  52. public IPAddress[] GetLocalIpAddresses(bool ignoreVirtualInterface = true)
  53. {
  54. lock (_localIpAddressSyncLock)
  55. {
  56. if (_localIpAddresses == null)
  57. {
  58. var addresses = GetLocalIpAddressesInternal(ignoreVirtualInterface).ToArray();
  59. _localIpAddresses = addresses;
  60. }
  61. return _localIpAddresses;
  62. }
  63. }
  64. private List<IPAddress> GetLocalIpAddressesInternal(bool ignoreVirtualInterface)
  65. {
  66. var list = GetIPsDefault(ignoreVirtualInterface).ToList();
  67. if (list.Count == 0)
  68. {
  69. list = GetLocalIpAddressesFallback().GetAwaiter().GetResult().ToList();
  70. }
  71. var listClone = list.ToList();
  72. return list
  73. .OrderBy(i => i.AddressFamily == AddressFamily.InterNetwork ? 0 : 1)
  74. .ThenBy(i => listClone.IndexOf(i))
  75. .Where(FilterIpAddress)
  76. .GroupBy(i => i.ToString())
  77. .Select(x => x.First())
  78. .ToList();
  79. }
  80. private static bool FilterIpAddress(IPAddress address)
  81. {
  82. if (address.IsIPv6LinkLocal
  83. || address.ToString().StartsWith("169.", StringComparison.OrdinalIgnoreCase))
  84. {
  85. return false;
  86. }
  87. return true;
  88. }
  89. public bool IsInPrivateAddressSpace(string endpoint)
  90. {
  91. return IsInPrivateAddressSpace(endpoint, true);
  92. }
  93. private bool IsInPrivateAddressSpace(string endpoint, bool checkSubnets)
  94. {
  95. if (string.Equals(endpoint, "::1", StringComparison.OrdinalIgnoreCase))
  96. {
  97. return true;
  98. }
  99. // ipv6
  100. if (endpoint.Split('.').Length > 4)
  101. {
  102. // Handle ipv4 mapped to ipv6
  103. var originalEndpoint = endpoint;
  104. endpoint = endpoint.Replace("::ffff:", string.Empty);
  105. if (string.Equals(endpoint, originalEndpoint, StringComparison.OrdinalIgnoreCase))
  106. {
  107. return false;
  108. }
  109. }
  110. // Private address space:
  111. // http://en.wikipedia.org/wiki/Private_network
  112. if (endpoint.StartsWith("172.", StringComparison.OrdinalIgnoreCase))
  113. {
  114. return Is172AddressPrivate(endpoint);
  115. }
  116. if (endpoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) ||
  117. endpoint.StartsWith("127.", StringComparison.OrdinalIgnoreCase) ||
  118. endpoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase))
  119. {
  120. return true;
  121. }
  122. if (checkSubnets && endpoint.StartsWith("192.168", StringComparison.OrdinalIgnoreCase))
  123. {
  124. return true;
  125. }
  126. if (checkSubnets && IsInPrivateAddressSpaceAndLocalSubnet(endpoint))
  127. {
  128. return true;
  129. }
  130. return false;
  131. }
  132. public bool IsInPrivateAddressSpaceAndLocalSubnet(string endpoint)
  133. {
  134. if (endpoint.StartsWith("10.", StringComparison.OrdinalIgnoreCase))
  135. {
  136. var endpointFirstPart = endpoint.Split('.')[0];
  137. var subnets = GetSubnets(endpointFirstPart);
  138. foreach (var subnet_Match in subnets)
  139. {
  140. //logger.LogDebug("subnet_Match:" + subnet_Match);
  141. if (endpoint.StartsWith(subnet_Match + ".", StringComparison.OrdinalIgnoreCase))
  142. {
  143. return true;
  144. }
  145. }
  146. }
  147. return false;
  148. }
  149. private List<string> GetSubnets(string endpointFirstPart)
  150. {
  151. lock (_subnetLookupLock)
  152. {
  153. if (_subnetLookup.TryGetValue(endpointFirstPart, out var subnets))
  154. {
  155. return subnets;
  156. }
  157. subnets = new List<string>();
  158. foreach (var adapter in NetworkInterface.GetAllNetworkInterfaces())
  159. {
  160. foreach (var unicastIPAddressInformation in adapter.GetIPProperties().UnicastAddresses)
  161. {
  162. if (unicastIPAddressInformation.Address.AddressFamily == AddressFamily.InterNetwork && endpointFirstPart == unicastIPAddressInformation.Address.ToString().Split('.')[0])
  163. {
  164. int subnet_Test = 0;
  165. foreach (string part in unicastIPAddressInformation.IPv4Mask.ToString().Split('.'))
  166. {
  167. if (part.Equals("0", StringComparison.Ordinal))
  168. {
  169. break;
  170. }
  171. subnet_Test++;
  172. }
  173. var subnet_Match = string.Join(".", unicastIPAddressInformation.Address.ToString().Split('.').Take(subnet_Test).ToArray());
  174. // TODO: Is this check necessary?
  175. if (adapter.OperationalStatus == OperationalStatus.Up)
  176. {
  177. subnets.Add(subnet_Match);
  178. }
  179. }
  180. }
  181. }
  182. _subnetLookup[endpointFirstPart] = subnets;
  183. return subnets;
  184. }
  185. }
  186. private static bool Is172AddressPrivate(string endpoint)
  187. {
  188. for (var i = 16; i <= 31; i++)
  189. {
  190. if (endpoint.StartsWith("172." + i.ToString(CultureInfo.InvariantCulture) + ".", StringComparison.OrdinalIgnoreCase))
  191. {
  192. return true;
  193. }
  194. }
  195. return false;
  196. }
  197. public bool IsInLocalNetwork(string endpoint)
  198. {
  199. return IsInLocalNetworkInternal(endpoint, true);
  200. }
  201. public bool IsAddressInSubnets(string addressString, string[] subnets)
  202. {
  203. return IsAddressInSubnets(IPAddress.Parse(addressString), addressString, subnets);
  204. }
  205. private static bool IsAddressInSubnets(IPAddress address, string addressString, string[] subnets)
  206. {
  207. foreach (var subnet in subnets)
  208. {
  209. var normalizedSubnet = subnet.Trim();
  210. if (string.Equals(normalizedSubnet, addressString, StringComparison.OrdinalIgnoreCase))
  211. {
  212. return true;
  213. }
  214. if (normalizedSubnet.IndexOf('/') != -1)
  215. {
  216. var ipnetwork = IPNetwork.Parse(normalizedSubnet);
  217. if (ipnetwork.Contains(address))
  218. {
  219. return true;
  220. }
  221. }
  222. }
  223. return false;
  224. }
  225. private bool IsInLocalNetworkInternal(string endpoint, bool resolveHost)
  226. {
  227. if (string.IsNullOrEmpty(endpoint))
  228. {
  229. throw new ArgumentNullException(nameof(endpoint));
  230. }
  231. if (IPAddress.TryParse(endpoint, out var address))
  232. {
  233. var addressString = address.ToString();
  234. var localSubnetsFn = LocalSubnetsFn;
  235. if (localSubnetsFn != null)
  236. {
  237. var localSubnets = localSubnetsFn();
  238. foreach (var subnet in localSubnets)
  239. {
  240. // only validate if there's at least one valid entry
  241. if (!string.IsNullOrWhiteSpace(subnet))
  242. {
  243. return IsAddressInSubnets(address, addressString, localSubnets) || IsInPrivateAddressSpace(addressString, false);
  244. }
  245. }
  246. }
  247. int lengthMatch = 100;
  248. if (address.AddressFamily == AddressFamily.InterNetwork)
  249. {
  250. lengthMatch = 4;
  251. if (IsInPrivateAddressSpace(addressString, true))
  252. {
  253. return true;
  254. }
  255. }
  256. else if (address.AddressFamily == AddressFamily.InterNetworkV6)
  257. {
  258. lengthMatch = 9;
  259. if (IsInPrivateAddressSpace(endpoint, true))
  260. {
  261. return true;
  262. }
  263. }
  264. // Should be even be doing this with ipv6?
  265. if (addressString.Length >= lengthMatch)
  266. {
  267. var prefix = addressString.Substring(0, lengthMatch);
  268. if (GetLocalIpAddresses().Any(i => i.ToString().StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
  269. {
  270. return true;
  271. }
  272. }
  273. }
  274. else if (resolveHost)
  275. {
  276. if (Uri.TryCreate(endpoint, UriKind.RelativeOrAbsolute, out var uri))
  277. {
  278. try
  279. {
  280. var host = uri.DnsSafeHost;
  281. _logger.LogDebug("Resolving host {0}", host);
  282. address = GetIpAddresses(host).Result.FirstOrDefault();
  283. if (address != null)
  284. {
  285. _logger.LogDebug("{0} resolved to {1}", host, address);
  286. return IsInLocalNetworkInternal(address.ToString(), false);
  287. }
  288. }
  289. catch (InvalidOperationException)
  290. {
  291. // Can happen with reverse proxy or IIS url rewriting
  292. }
  293. catch (Exception ex)
  294. {
  295. _logger.LogError(ex, "Error resolving hostname");
  296. }
  297. }
  298. }
  299. return false;
  300. }
  301. private static Task<IPAddress[]> GetIpAddresses(string hostName)
  302. {
  303. return Dns.GetHostAddressesAsync(hostName);
  304. }
  305. private IEnumerable<IPAddress> GetIPsDefault(bool ignoreVirtualInterface)
  306. {
  307. IEnumerable<NetworkInterface> interfaces;
  308. try
  309. {
  310. interfaces = NetworkInterface.GetAllNetworkInterfaces()
  311. .Where(x => x.OperationalStatus == OperationalStatus.Up
  312. || x.OperationalStatus == OperationalStatus.Unknown);
  313. }
  314. catch (NetworkInformationException ex)
  315. {
  316. _logger.LogError(ex, "Error in GetAllNetworkInterfaces");
  317. return Enumerable.Empty<IPAddress>();
  318. }
  319. return interfaces.SelectMany(network =>
  320. {
  321. var ipProperties = network.GetIPProperties();
  322. // Try to exclude virtual adapters
  323. // http://stackoverflow.com/questions/8089685/c-sharp-finding-my-machines-local-ip-address-and-not-the-vms
  324. var addr = ipProperties.GatewayAddresses.FirstOrDefault();
  325. if (addr == null
  326. || (ignoreVirtualInterface
  327. && (addr.Address.Equals(IPAddress.Any) || addr.Address.Equals(IPAddress.IPv6Any))))
  328. {
  329. return Enumerable.Empty<IPAddress>();
  330. }
  331. return ipProperties.UnicastAddresses
  332. .Select(i => i.Address)
  333. .Where(i => i.AddressFamily == AddressFamily.InterNetwork || i.AddressFamily == AddressFamily.InterNetworkV6);
  334. }).GroupBy(i => i.ToString())
  335. .Select(x => x.First());
  336. }
  337. private static async Task<IEnumerable<IPAddress>> GetLocalIpAddressesFallback()
  338. {
  339. var host = await Dns.GetHostEntryAsync(Dns.GetHostName()).ConfigureAwait(false);
  340. // Reverse them because the last one is usually the correct one
  341. // It's not fool-proof so ultimately the consumer will have to examine them and decide
  342. return host.AddressList
  343. .Where(i => i.AddressFamily == AddressFamily.InterNetwork || i.AddressFamily == AddressFamily.InterNetworkV6)
  344. .Reverse();
  345. }
  346. /// <summary>
  347. /// Gets a random port number that is currently available
  348. /// </summary>
  349. /// <returns>System.Int32.</returns>
  350. public int GetRandomUnusedTcpPort()
  351. {
  352. var listener = new TcpListener(IPAddress.Any, 0);
  353. listener.Start();
  354. var port = ((IPEndPoint)listener.LocalEndpoint).Port;
  355. listener.Stop();
  356. return port;
  357. }
  358. public int GetRandomUnusedUdpPort()
  359. {
  360. var localEndPoint = new IPEndPoint(IPAddress.Any, 0);
  361. using (var udpClient = new UdpClient(localEndPoint))
  362. {
  363. var port = ((IPEndPoint)udpClient.Client.LocalEndPoint).Port;
  364. return port;
  365. }
  366. }
  367. private List<PhysicalAddress> _macAddresses;
  368. public List<PhysicalAddress> GetMacAddresses()
  369. {
  370. if (_macAddresses == null)
  371. {
  372. _macAddresses = GetMacAddressesInternal().ToList();
  373. }
  374. return _macAddresses;
  375. }
  376. private static IEnumerable<PhysicalAddress> GetMacAddressesInternal()
  377. => NetworkInterface.GetAllNetworkInterfaces()
  378. .Where(i => i.NetworkInterfaceType != NetworkInterfaceType.Loopback)
  379. .Select(x => x.GetPhysicalAddress())
  380. .Where(x => x != null && x != PhysicalAddress.None);
  381. /// <summary>
  382. /// Parses the specified endpointstring.
  383. /// </summary>
  384. /// <param name="endpointstring">The endpointstring.</param>
  385. /// <returns>IPEndPoint.</returns>
  386. public IPEndPoint Parse(string endpointstring)
  387. {
  388. return Parse(endpointstring, -1).Result;
  389. }
  390. /// <summary>
  391. /// Parses the specified endpointstring.
  392. /// </summary>
  393. /// <param name="endpointstring">The endpointstring.</param>
  394. /// <param name="defaultport">The defaultport.</param>
  395. /// <returns>IPEndPoint.</returns>
  396. /// <exception cref="ArgumentException">Endpoint descriptor may not be empty.</exception>
  397. /// <exception cref="FormatException"></exception>
  398. private static async Task<IPEndPoint> Parse(string endpointstring, int defaultport)
  399. {
  400. if (string.IsNullOrEmpty(endpointstring)
  401. || endpointstring.Trim().Length == 0)
  402. {
  403. throw new ArgumentException("Endpoint descriptor may not be empty.");
  404. }
  405. if (defaultport != -1 &&
  406. (defaultport < IPEndPoint.MinPort
  407. || defaultport > IPEndPoint.MaxPort))
  408. {
  409. throw new ArgumentException(string.Format("Invalid default port '{0}'", defaultport));
  410. }
  411. string[] values = endpointstring.Split(new char[] { ':' });
  412. IPAddress ipaddy;
  413. int port = -1;
  414. //check if we have an IPv6 or ports
  415. if (values.Length <= 2) // ipv4 or hostname
  416. {
  417. port = values.Length == 1 ? defaultport : GetPort(values[1]);
  418. //try to use the address as IPv4, otherwise get hostname
  419. if (!IPAddress.TryParse(values[0], out ipaddy))
  420. ipaddy = await GetIPfromHost(values[0]).ConfigureAwait(false);
  421. }
  422. else if (values.Length > 2) //ipv6
  423. {
  424. //could [a:b:c]:d
  425. if (values[0].StartsWith("[") && values[values.Length - 2].EndsWith("]"))
  426. {
  427. string ipaddressstring = string.Join(":", values.Take(values.Length - 1).ToArray());
  428. ipaddy = IPAddress.Parse(ipaddressstring);
  429. port = GetPort(values[values.Length - 1]);
  430. }
  431. else //[a:b:c] or a:b:c
  432. {
  433. ipaddy = IPAddress.Parse(endpointstring);
  434. port = defaultport;
  435. }
  436. }
  437. else
  438. {
  439. throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
  440. }
  441. if (port == -1)
  442. throw new ArgumentException(string.Format("No port specified: '{0}'", endpointstring));
  443. return new IPEndPoint(ipaddy, port);
  444. }
  445. protected static readonly CultureInfo UsCulture = new CultureInfo("en-US");
  446. /// <summary>
  447. /// Gets the port.
  448. /// </summary>
  449. /// <param name="p">The p.</param>
  450. /// <returns>System.Int32.</returns>
  451. /// <exception cref="FormatException"></exception>
  452. private static int GetPort(string p)
  453. {
  454. if (!int.TryParse(p, out var port)
  455. || port < IPEndPoint.MinPort
  456. || port > IPEndPoint.MaxPort)
  457. {
  458. throw new FormatException(string.Format("Invalid end point port '{0}'", p));
  459. }
  460. return port;
  461. }
  462. /// <summary>
  463. /// Gets the I pfrom host.
  464. /// </summary>
  465. /// <param name="p">The p.</param>
  466. /// <returns>IPAddress.</returns>
  467. /// <exception cref="ArgumentException"></exception>
  468. private static async Task<IPAddress> GetIPfromHost(string p)
  469. {
  470. var hosts = await Dns.GetHostAddressesAsync(p).ConfigureAwait(false);
  471. if (hosts == null || hosts.Length == 0)
  472. throw new ArgumentException(string.Format("Host not found: {0}", p));
  473. return hosts[0];
  474. }
  475. public bool IsInSameSubnet(IPAddress address1, IPAddress address2, IPAddress subnetMask)
  476. {
  477. IPAddress network1 = GetNetworkAddress(address1, subnetMask);
  478. IPAddress network2 = GetNetworkAddress(address2, subnetMask);
  479. return network1.Equals(network2);
  480. }
  481. private IPAddress GetNetworkAddress(IPAddress address, IPAddress subnetMask)
  482. {
  483. byte[] ipAdressBytes = address.GetAddressBytes();
  484. byte[] subnetMaskBytes = subnetMask.GetAddressBytes();
  485. if (ipAdressBytes.Length != subnetMaskBytes.Length)
  486. {
  487. throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
  488. }
  489. byte[] broadcastAddress = new byte[ipAdressBytes.Length];
  490. for (int i = 0; i < broadcastAddress.Length; i++)
  491. {
  492. broadcastAddress[i] = (byte)(ipAdressBytes[i] & (subnetMaskBytes[i]));
  493. }
  494. return new IPAddress(broadcastAddress);
  495. }
  496. public IPAddress GetLocalIpSubnetMask(IPAddress address)
  497. {
  498. NetworkInterface[] interfaces;
  499. try
  500. {
  501. var validStatuses = new[] { OperationalStatus.Up, OperationalStatus.Unknown };
  502. interfaces = NetworkInterface.GetAllNetworkInterfaces()
  503. .Where(i => validStatuses.Contains(i.OperationalStatus))
  504. .ToArray();
  505. }
  506. catch (Exception ex)
  507. {
  508. _logger.LogError(ex, "Error in GetAllNetworkInterfaces");
  509. return null;
  510. }
  511. foreach (NetworkInterface ni in interfaces)
  512. {
  513. if (ni.GetIPProperties().GatewayAddresses.FirstOrDefault() != null)
  514. {
  515. foreach (UnicastIPAddressInformation ip in ni.GetIPProperties().UnicastAddresses)
  516. {
  517. if (ip.Address.Equals(address) && ip.IPv4Mask != null)
  518. {
  519. return ip.IPv4Mask;
  520. }
  521. }
  522. }
  523. }
  524. return null;
  525. }
  526. /// <summary>
  527. /// Gets the network shares.
  528. /// </summary>
  529. /// <param name="path">The path.</param>
  530. /// <returns>IEnumerable{NetworkShare}.</returns>
  531. public virtual IEnumerable<NetworkShare> GetNetworkShares(string path)
  532. {
  533. return new List<NetworkShare>();
  534. }
  535. /// <summary>
  536. /// Gets available devices within the domain
  537. /// </summary>
  538. /// <returns>PC's in the Domain</returns>
  539. public virtual IEnumerable<FileSystemEntryInfo> GetNetworkDevices()
  540. {
  541. return new List<FileSystemEntryInfo>();
  542. }
  543. }
  544. }