NetworkExtensions.cs 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics.CodeAnalysis;
  4. using System.Linq;
  5. using System.Net;
  6. using System.Net.Sockets;
  7. using System.Text.RegularExpressions;
  8. using Jellyfin.Extensions;
  9. using Microsoft.AspNetCore.HttpOverrides;
  10. namespace MediaBrowser.Common.Net
  11. {
  12. /// <summary>
  13. /// Defines the <see cref="NetworkExtensions" />.
  14. /// </summary>
  15. public static class NetworkExtensions
  16. {
  17. // Use regular expression as CheckHostName isn't RFC5892 compliant.
  18. // Modified from gSkinner's expression at https://stackoverflow.com/questions/11809631/fully-qualified-domain-name-validation
  19. private static readonly Regex _fqdnRegex = new Regex(@"(?im)^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){0,127}(?![0-9]*$)[a-z0-9-]+\.?)(:(\d){1,5}){0,1}$");
  20. /// <summary>
  21. /// Returns true if the IPAddress contains an IP6 Local link address.
  22. /// </summary>
  23. /// <param name="address">IPAddress object to check.</param>
  24. /// <returns>True if it is a local link address.</returns>
  25. /// <remarks>
  26. /// See https://stackoverflow.com/questions/6459928/explain-the-instance-properties-of-system-net-ipaddress
  27. /// it appears that the IPAddress.IsIPv6LinkLocal is out of date.
  28. /// </remarks>
  29. public static bool IsIPv6LinkLocal(IPAddress address)
  30. {
  31. ArgumentNullException.ThrowIfNull(address);
  32. if (address.IsIPv4MappedToIPv6)
  33. {
  34. address = address.MapToIPv4();
  35. }
  36. if (address.AddressFamily != AddressFamily.InterNetworkV6)
  37. {
  38. return false;
  39. }
  40. // GetAddressBytes
  41. Span<byte> octet = stackalloc byte[16];
  42. address.TryWriteBytes(octet, out _);
  43. uint word = (uint)(octet[0] << 8) + octet[1];
  44. return word >= 0xfe80 && word <= 0xfebf; // fe80::/10 :Local link.
  45. }
  46. /// <summary>
  47. /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only.
  48. /// </summary>
  49. /// <param name="cidr">Subnet mask in CIDR notation.</param>
  50. /// <param name="family">IPv4 or IPv6 family.</param>
  51. /// <returns>String value of the subnet mask in dotted decimal notation.</returns>
  52. public static IPAddress CidrToMask(byte cidr, AddressFamily family)
  53. {
  54. uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? 32 : 128) - cidr);
  55. addr = ((addr & 0xff000000) >> 24)
  56. | ((addr & 0x00ff0000) >> 8)
  57. | ((addr & 0x0000ff00) << 8)
  58. | ((addr & 0x000000ff) << 24);
  59. return new IPAddress(addr);
  60. }
  61. /// <summary>
  62. /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only.
  63. /// </summary>
  64. /// <param name="cidr">Subnet mask in CIDR notation.</param>
  65. /// <param name="family">IPv4 or IPv6 family.</param>
  66. /// <returns>String value of the subnet mask in dotted decimal notation.</returns>
  67. public static IPAddress CidrToMask(int cidr, AddressFamily family)
  68. {
  69. uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? 32 : 128) - cidr);
  70. addr = ((addr & 0xff000000) >> 24)
  71. | ((addr & 0x00ff0000) >> 8)
  72. | ((addr & 0x0000ff00) << 8)
  73. | ((addr & 0x000000ff) << 24);
  74. return new IPAddress(addr);
  75. }
  76. /// <summary>
  77. /// Convert a subnet mask to a CIDR. IPv4 only.
  78. /// https://stackoverflow.com/questions/36954345/get-cidr-from-netmask.
  79. /// </summary>
  80. /// <param name="mask">Subnet mask.</param>
  81. /// <returns>Byte CIDR representing the mask.</returns>
  82. public static byte MaskToCidr(IPAddress mask)
  83. {
  84. ArgumentNullException.ThrowIfNull(mask);
  85. byte cidrnet = 0;
  86. if (mask.Equals(IPAddress.Any))
  87. {
  88. return cidrnet;
  89. }
  90. // GetAddressBytes
  91. Span<byte> bytes = stackalloc byte[mask.AddressFamily == AddressFamily.InterNetwork ? 4 : 16];
  92. if (!mask.TryWriteBytes(bytes, out var bytesWritten))
  93. {
  94. Console.WriteLine("Unable to write address bytes, only {Bytes} bytes written.", bytesWritten);
  95. }
  96. var zeroed = false;
  97. for (var i = 0; i < bytes.Length; i++)
  98. {
  99. for (int v = bytes[i]; (v & 0xFF) != 0; v <<= 1)
  100. {
  101. if (zeroed)
  102. {
  103. // Invalid netmask.
  104. return (byte)~cidrnet;
  105. }
  106. if ((v & 0x80) == 0)
  107. {
  108. zeroed = true;
  109. }
  110. else
  111. {
  112. cidrnet++;
  113. }
  114. }
  115. }
  116. return cidrnet;
  117. }
  118. /// <summary>
  119. /// Converts an IPAddress into a string.
  120. /// IPv6 addresses are returned in [ ], with their scope removed.
  121. /// </summary>
  122. /// <param name="address">Address to convert.</param>
  123. /// <returns>URI safe conversion of the address.</returns>
  124. public static string FormatIPString(IPAddress? address)
  125. {
  126. if (address is null)
  127. {
  128. return string.Empty;
  129. }
  130. var str = address.ToString();
  131. if (address.AddressFamily == AddressFamily.InterNetworkV6)
  132. {
  133. int i = str.IndexOf('%', StringComparison.Ordinal);
  134. if (i != -1)
  135. {
  136. str = str.Substring(0, i);
  137. }
  138. return $"[{str}]";
  139. }
  140. return str;
  141. }
  142. /// <summary>
  143. /// Try parsing an array of strings into <see cref="IPNetwork"/> objects, respecting exclusions.
  144. /// Elements without a subnet mask will be represented as <see cref="IPNetwork"/> with a single IP.
  145. /// </summary>
  146. /// <param name="values">Input string array to be parsed.</param>
  147. /// <param name="result">Collection of <see cref="IPNetwork"/>.</param>
  148. /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
  149. /// <returns><c>True</c> if parsing was successful.</returns>
  150. public static bool TryParseToSubnets(string[] values, [NotNullWhen(true)] out IReadOnlyList<IPNetwork>? result, bool negated = false)
  151. {
  152. if (values is null || values.Length == 0)
  153. {
  154. result = null;
  155. return false;
  156. }
  157. var tmpResult = new List<IPNetwork>();
  158. for (int a = 0; a < values.Length; a++)
  159. {
  160. if (TryParseToSubnet(values[a], out var innerResult, negated))
  161. {
  162. tmpResult.Add(innerResult);
  163. }
  164. }
  165. if (tmpResult.Count > 0)
  166. {
  167. result = tmpResult;
  168. return true;
  169. }
  170. result = null;
  171. return false;
  172. }
  173. /// <summary>
  174. /// Try parsing a string into an <see cref="IPNetwork"/>, respecting exclusions.
  175. /// Inputs without a subnet mask will be represented as <see cref="IPNetwork"/> with a single IP.
  176. /// </summary>
  177. /// <param name="value">Input string to be parsed.</param>
  178. /// <param name="result">An <see cref="IPNetwork"/>.</param>
  179. /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
  180. /// <returns><c>True</c> if parsing was successful.</returns>
  181. public static bool TryParseToSubnet(ReadOnlySpan<char> value, [NotNullWhen(true)] out IPNetwork? result, bool negated = false)
  182. {
  183. var splitString = value.Trim().Split('/');
  184. if (splitString.MoveNext())
  185. {
  186. var ipBlock = splitString.Current;
  187. var address = IPAddress.None;
  188. if (negated && ipBlock.StartsWith("!") && IPAddress.TryParse(ipBlock[1..], out var tmpAddress))
  189. {
  190. address = tmpAddress;
  191. }
  192. else if (!negated && IPAddress.TryParse(ipBlock, out tmpAddress))
  193. {
  194. address = tmpAddress;
  195. }
  196. if (address != IPAddress.None)
  197. {
  198. if (splitString.MoveNext())
  199. {
  200. var subnetBlock = splitString.Current;
  201. if (int.TryParse(subnetBlock, out var netmask))
  202. {
  203. result = new IPNetwork(address, netmask);
  204. return true;
  205. }
  206. else if (IPAddress.TryParse(subnetBlock, out var netmaskAddress))
  207. {
  208. result = new IPNetwork(address, NetworkExtensions.MaskToCidr(netmaskAddress));
  209. return true;
  210. }
  211. }
  212. else if (address.AddressFamily == AddressFamily.InterNetwork)
  213. {
  214. result = new IPNetwork(address, 32);
  215. return true;
  216. }
  217. else if (address.AddressFamily == AddressFamily.InterNetworkV6)
  218. {
  219. result = new IPNetwork(address, 128);
  220. return true;
  221. }
  222. }
  223. }
  224. result = null;
  225. return false;
  226. }
  227. /// <summary>
  228. /// Attempts to parse a host span.
  229. /// </summary>
  230. /// <param name="host">Host name to parse.</param>
  231. /// <param name="addresses">Object representing the span, if it has successfully been parsed.</param>
  232. /// <param name="isIPv4Enabled"><c>true</c> if IPv4 is enabled.</param>
  233. /// <param name="isIPv6Enabled"><c>true</c> if IPv6 is enabled.</param>
  234. /// <returns><c>true</c> if the parsing is successful, <c>false</c> if not.</returns>
  235. public static bool TryParseHost(ReadOnlySpan<char> host, [NotNullWhen(true)] out IPAddress[]? addresses, bool isIPv4Enabled = true, bool isIPv6Enabled = false)
  236. {
  237. if (host.IsEmpty)
  238. {
  239. addresses = null;
  240. return false;
  241. }
  242. host = host.Trim();
  243. // See if it's an IPv6 with port address e.g. [::1] or [::1]:120.
  244. if (host[0] == '[')
  245. {
  246. int i = host.IndexOf("]", StringComparison.Ordinal);
  247. if (i != -1)
  248. {
  249. return TryParseHost(host[1..(i - 1)], out addresses);
  250. }
  251. addresses = Array.Empty<IPAddress>();
  252. return false;
  253. }
  254. var hosts = new List<string>();
  255. foreach (var splitSpan in host.Split(':'))
  256. {
  257. hosts.Add(splitSpan.ToString());
  258. }
  259. if (hosts.Count <= 2)
  260. {
  261. // Is hostname or hostname:port
  262. if (_fqdnRegex.IsMatch(hosts[0]))
  263. {
  264. try
  265. {
  266. addresses = Dns.GetHostAddresses(hosts[0]);
  267. return true;
  268. }
  269. catch (SocketException)
  270. {
  271. // Log and then ignore socket errors, as the result value will just be an empty array.
  272. Console.WriteLine("GetHostAddresses failed.");
  273. }
  274. }
  275. // Is an IP4 or IP4:port
  276. if (IPAddress.TryParse(hosts[0].AsSpan().LeftPart('/'), out var address))
  277. {
  278. if (((address.AddressFamily == AddressFamily.InterNetwork) && (!isIPv4Enabled && isIPv6Enabled)) ||
  279. ((address.AddressFamily == AddressFamily.InterNetworkV6) && (isIPv4Enabled && !isIPv6Enabled)))
  280. {
  281. addresses = Array.Empty<IPAddress>();
  282. return false;
  283. }
  284. addresses = new[] { address };
  285. // Host name is an ip4 address, so fake resolve.
  286. return true;
  287. }
  288. }
  289. else if (hosts.Count > 0 && hosts.Count <= 9) // 8 octets + port
  290. {
  291. if (IPAddress.TryParse(host.LeftPart('/'), out var address))
  292. {
  293. addresses = new[] { address };
  294. return true;
  295. }
  296. }
  297. addresses = Array.Empty<IPAddress>();
  298. return false;
  299. }
  300. /// <summary>
  301. /// Gets the broadcast address for a <see cref="IPNetwork"/>.
  302. /// </summary>
  303. /// <param name="network">The <see cref="IPNetwork"/>.</param>
  304. /// <returns>The broadcast address.</returns>
  305. public static IPAddress GetBroadcastAddress(IPNetwork network)
  306. {
  307. var addressBytes = network.Prefix.GetAddressBytes();
  308. if (BitConverter.IsLittleEndian)
  309. {
  310. addressBytes.Reverse();
  311. }
  312. uint iPAddress = BitConverter.ToUInt32(addressBytes, 0);
  313. uint ipMaskV4 = BitConverter.ToUInt32(CidrToMask(network.PrefixLength, AddressFamily.InterNetwork).GetAddressBytes(), 0);
  314. uint broadCastIPAddress = iPAddress | ~ipMaskV4;
  315. return new IPAddress(BitConverter.GetBytes(broadCastIPAddress));
  316. }
  317. }
  318. }