BaseNetworkManager.cs 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377
  1. using MediaBrowser.Model.Logging;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Globalization;
  5. using System.Linq;
  6. using System.Net;
  7. using System.Net.NetworkInformation;
  8. using System.Net.Sockets;
  9. namespace MediaBrowser.Common.Implementations.Networking
  10. {
  11. public abstract class BaseNetworkManager
  12. {
  13. protected ILogger Logger { get; private set; }
  14. protected BaseNetworkManager(ILogger logger)
  15. {
  16. Logger = logger;
  17. }
  18. private volatile List<string> _localIpAddresses;
  19. private readonly object _localIpAddressSyncLock = new object();
  20. /// <summary>
  21. /// Gets the machine's local ip address
  22. /// </summary>
  23. /// <returns>IPAddress.</returns>
  24. public IEnumerable<string> GetLocalIpAddresses()
  25. {
  26. if (_localIpAddresses == null)
  27. {
  28. lock (_localIpAddressSyncLock)
  29. {
  30. if (_localIpAddresses == null)
  31. {
  32. var addresses = GetLocalIpAddressesInternal().ToList();
  33. _localIpAddresses = addresses;
  34. BindEvents();
  35. return addresses;
  36. }
  37. }
  38. }
  39. return _localIpAddresses;
  40. }
  41. private void BindEvents()
  42. {
  43. NetworkChange.NetworkAddressChanged -= NetworkChange_NetworkAddressChanged;
  44. NetworkChange.NetworkAvailabilityChanged -= NetworkChange_NetworkAvailabilityChanged;
  45. NetworkChange.NetworkAddressChanged += NetworkChange_NetworkAddressChanged;
  46. NetworkChange.NetworkAvailabilityChanged += NetworkChange_NetworkAvailabilityChanged;
  47. }
  48. void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
  49. {
  50. Logger.Debug("NetworkAvailabilityChanged fired. Resetting cached network info.");
  51. lock (_localIpAddressSyncLock)
  52. {
  53. _localIpAddresses = null;
  54. }
  55. }
  56. void NetworkChange_NetworkAddressChanged(object sender, EventArgs e)
  57. {
  58. Logger.Debug("NetworkAddressChanged fired. Resetting cached network info.");
  59. lock (_localIpAddressSyncLock)
  60. {
  61. _localIpAddresses = null;
  62. }
  63. }
  64. private IEnumerable<string> GetLocalIpAddressesInternal()
  65. {
  66. var list = GetIPsDefault()
  67. .Where(i => !IPAddress.IsLoopback(i))
  68. .Select(i => i.ToString())
  69. .Where(FilterIpAddress)
  70. .ToList();
  71. if (list.Count > 0)
  72. {
  73. return list;
  74. }
  75. return GetLocalIpAddressesFallback().Where(FilterIpAddress);
  76. }
  77. private bool FilterIpAddress(string address)
  78. {
  79. if (address.StartsWith("169.", StringComparison.OrdinalIgnoreCase))
  80. {
  81. return false;
  82. }
  83. return true;
  84. }
  85. private bool IsInPrivateAddressSpace(string endpoint)
  86. {
  87. // Private address space:
  88. // http://en.wikipedia.org/wiki/Private_network
  89. if (endpoint.StartsWith("172.", StringComparison.OrdinalIgnoreCase))
  90. {
  91. return Is172AddressPrivate(endpoint);
  92. }
  93. return
  94. // If url was requested with computer name, we may see this
  95. endpoint.IndexOf("::", StringComparison.OrdinalIgnoreCase) != -1 ||
  96. endpoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) ||
  97. endpoint.StartsWith("127.", StringComparison.OrdinalIgnoreCase) ||
  98. endpoint.StartsWith("10.", StringComparison.OrdinalIgnoreCase) ||
  99. endpoint.StartsWith("192.168", StringComparison.OrdinalIgnoreCase) ||
  100. endpoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase);
  101. }
  102. private bool Is172AddressPrivate(string endpoint)
  103. {
  104. for (var i = 16; i <= 31; i++)
  105. {
  106. if (endpoint.StartsWith("172." + i.ToString(CultureInfo.InvariantCulture) + ".", StringComparison.OrdinalIgnoreCase))
  107. {
  108. return true;
  109. }
  110. }
  111. return false;
  112. }
  113. public bool IsInLocalNetwork(string endpoint)
  114. {
  115. return IsInLocalNetworkInternal(endpoint, true);
  116. }
  117. public bool IsInLocalNetworkInternal(string endpoint, bool resolveHost)
  118. {
  119. if (string.IsNullOrWhiteSpace(endpoint))
  120. {
  121. throw new ArgumentNullException("endpoint");
  122. }
  123. if (IsInPrivateAddressSpace(endpoint))
  124. {
  125. return true;
  126. }
  127. const int lengthMatch = 4;
  128. if (endpoint.Length >= lengthMatch)
  129. {
  130. var prefix = endpoint.Substring(0, lengthMatch);
  131. if (GetLocalIpAddresses()
  132. .Any(i => i.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
  133. {
  134. return true;
  135. }
  136. }
  137. IPAddress address;
  138. if (resolveHost && !IPAddress.TryParse(endpoint, out address))
  139. {
  140. Uri uri;
  141. if (Uri.TryCreate(endpoint, UriKind.RelativeOrAbsolute, out uri))
  142. {
  143. var host = uri.DnsSafeHost;
  144. Logger.Debug("Resolving host {0}", host);
  145. try
  146. {
  147. address = GetIpAddresses(host).FirstOrDefault();
  148. if (address != null)
  149. {
  150. Logger.Debug("{0} resolved to {1}", host, address);
  151. return IsInLocalNetworkInternal(address.ToString(), false);
  152. }
  153. }
  154. catch (Exception ex)
  155. {
  156. Logger.ErrorException("Error resovling hostname {0}", ex, host);
  157. }
  158. }
  159. }
  160. return false;
  161. }
  162. public IEnumerable<IPAddress> GetIpAddresses(string hostName)
  163. {
  164. return Dns.GetHostAddresses(hostName);
  165. }
  166. private IEnumerable<IPAddress> GetIPsDefault()
  167. {
  168. foreach (var adapter in NetworkInterface.GetAllNetworkInterfaces())
  169. {
  170. var props = adapter.GetIPProperties();
  171. var gateways = from ga in props.GatewayAddresses
  172. where !ga.Address.Equals(IPAddress.Any)
  173. select true;
  174. if (!gateways.Any())
  175. {
  176. continue;
  177. }
  178. foreach (var uni in props.UnicastAddresses)
  179. {
  180. var address = uni.Address;
  181. if (address.AddressFamily != AddressFamily.InterNetwork)
  182. {
  183. continue;
  184. }
  185. yield return address;
  186. }
  187. }
  188. }
  189. private IEnumerable<string> GetLocalIpAddressesFallback()
  190. {
  191. var host = Dns.GetHostEntry(Dns.GetHostName());
  192. // Reverse them because the last one is usually the correct one
  193. // It's not fool-proof so ultimately the consumer will have to examine them and decide
  194. return host.AddressList
  195. .Where(i => i.AddressFamily == AddressFamily.InterNetwork)
  196. .Select(i => i.ToString())
  197. .Reverse();
  198. }
  199. /// <summary>
  200. /// Gets a random port number that is currently available
  201. /// </summary>
  202. /// <returns>System.Int32.</returns>
  203. public int GetRandomUnusedPort()
  204. {
  205. var listener = new TcpListener(IPAddress.Any, 0);
  206. listener.Start();
  207. var port = ((IPEndPoint)listener.LocalEndpoint).Port;
  208. listener.Stop();
  209. return port;
  210. }
  211. /// <summary>
  212. /// Returns MAC Address from first Network Card in Computer
  213. /// </summary>
  214. /// <returns>[string] MAC Address</returns>
  215. public string GetMacAddress()
  216. {
  217. return NetworkInterface.GetAllNetworkInterfaces()
  218. .Where(i => i.NetworkInterfaceType != NetworkInterfaceType.Loopback)
  219. .Select(i => BitConverter.ToString(i.GetPhysicalAddress().GetAddressBytes()))
  220. .FirstOrDefault();
  221. }
  222. /// <summary>
  223. /// Parses the specified endpointstring.
  224. /// </summary>
  225. /// <param name="endpointstring">The endpointstring.</param>
  226. /// <returns>IPEndPoint.</returns>
  227. public IPEndPoint Parse(string endpointstring)
  228. {
  229. return Parse(endpointstring, -1);
  230. }
  231. /// <summary>
  232. /// Parses the specified endpointstring.
  233. /// </summary>
  234. /// <param name="endpointstring">The endpointstring.</param>
  235. /// <param name="defaultport">The defaultport.</param>
  236. /// <returns>IPEndPoint.</returns>
  237. /// <exception cref="System.ArgumentException">Endpoint descriptor may not be empty.</exception>
  238. /// <exception cref="System.FormatException"></exception>
  239. private static IPEndPoint Parse(string endpointstring, int defaultport)
  240. {
  241. if (String.IsNullOrEmpty(endpointstring)
  242. || endpointstring.Trim().Length == 0)
  243. {
  244. throw new ArgumentException("Endpoint descriptor may not be empty.");
  245. }
  246. if (defaultport != -1 &&
  247. (defaultport < IPEndPoint.MinPort
  248. || defaultport > IPEndPoint.MaxPort))
  249. {
  250. throw new ArgumentException(String.Format("Invalid default port '{0}'", defaultport));
  251. }
  252. string[] values = endpointstring.Split(new char[] { ':' });
  253. IPAddress ipaddy;
  254. int port = -1;
  255. //check if we have an IPv6 or ports
  256. if (values.Length <= 2) // ipv4 or hostname
  257. {
  258. port = values.Length == 1 ? defaultport : GetPort(values[1]);
  259. //try to use the address as IPv4, otherwise get hostname
  260. if (!IPAddress.TryParse(values[0], out ipaddy))
  261. ipaddy = GetIPfromHost(values[0]);
  262. }
  263. else if (values.Length > 2) //ipv6
  264. {
  265. //could [a:b:c]:d
  266. if (values[0].StartsWith("[") && values[values.Length - 2].EndsWith("]"))
  267. {
  268. string ipaddressstring = String.Join(":", values.Take(values.Length - 1).ToArray());
  269. ipaddy = IPAddress.Parse(ipaddressstring);
  270. port = GetPort(values[values.Length - 1]);
  271. }
  272. else //[a:b:c] or a:b:c
  273. {
  274. ipaddy = IPAddress.Parse(endpointstring);
  275. port = defaultport;
  276. }
  277. }
  278. else
  279. {
  280. throw new FormatException(String.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
  281. }
  282. if (port == -1)
  283. throw new ArgumentException(String.Format("No port specified: '{0}'", endpointstring));
  284. return new IPEndPoint(ipaddy, port);
  285. }
  286. protected static readonly CultureInfo UsCulture = new CultureInfo("en-US");
  287. /// <summary>
  288. /// Gets the port.
  289. /// </summary>
  290. /// <param name="p">The p.</param>
  291. /// <returns>System.Int32.</returns>
  292. /// <exception cref="System.FormatException"></exception>
  293. private static int GetPort(string p)
  294. {
  295. int port;
  296. if (!Int32.TryParse(p, out port)
  297. || port < IPEndPoint.MinPort
  298. || port > IPEndPoint.MaxPort)
  299. {
  300. throw new FormatException(String.Format("Invalid end point port '{0}'", p));
  301. }
  302. return port;
  303. }
  304. /// <summary>
  305. /// Gets the I pfrom host.
  306. /// </summary>
  307. /// <param name="p">The p.</param>
  308. /// <returns>IPAddress.</returns>
  309. /// <exception cref="System.ArgumentException"></exception>
  310. private static IPAddress GetIPfromHost(string p)
  311. {
  312. var hosts = Dns.GetHostAddresses(p);
  313. if (hosts == null || hosts.Length == 0)
  314. throw new ArgumentException(String.Format("Host not found: {0}", p));
  315. return hosts[0];
  316. }
  317. }
  318. }