using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Net; using System.Net.Sockets; using System.Text.RegularExpressions; using Jellyfin.Extensions; using Jellyfin.Networking.Constants; using Microsoft.AspNetCore.HttpOverrides; namespace MediaBrowser.Common.Net; /// /// Defines the . /// public static partial class NetworkUtils { // Use regular expression as CheckHostName isn't RFC5892 compliant. // Modified from gSkinner's expression at https://stackoverflow.com/questions/11809631/fully-qualified-domain-name-validation [GeneratedRegex(@"(?im)^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){0,127}(?![0-9]*$)[a-z0-9-]+\.?)(:(\d){1,5}){0,1}$", RegexOptions.IgnoreCase, "en-US")] private static partial Regex FqdnGeneratedRegex(); /// /// Returns true if the IPAddress contains an IP6 Local link address. /// /// IPAddress object to check. /// True if it is a local link address. /// /// See https://stackoverflow.com/questions/6459928/explain-the-instance-properties-of-system-net-ipaddress /// it appears that the IPAddress.IsIPv6LinkLocal is out of date. /// public static bool IsIPv6LinkLocal(IPAddress address) { ArgumentNullException.ThrowIfNull(address); if (address.IsIPv4MappedToIPv6) { address = address.MapToIPv4(); } if (address.AddressFamily != AddressFamily.InterNetworkV6) { return false; } // GetAddressBytes Span octet = stackalloc byte[16]; address.TryWriteBytes(octet, out _); uint word = (uint)(octet[0] << 8) + octet[1]; return word >= 0xfe80 && word <= 0xfebf; // fe80::/10 :Local link. } /// /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only. /// /// Subnet mask in CIDR notation. /// IPv4 or IPv6 family. /// String value of the subnet mask in dotted decimal notation. public static IPAddress CidrToMask(byte cidr, AddressFamily family) { uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : NetworkConstants.MinimumIPv6PrefixSize) - cidr); addr = ((addr & 0xff000000) >> 24) | ((addr & 0x00ff0000) >> 8) | ((addr & 0x0000ff00) << 8) | ((addr & 0x000000ff) << 24); return new IPAddress(addr); } /// /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only. /// /// Subnet mask in CIDR notation. /// IPv4 or IPv6 family. /// String value of the subnet mask in dotted decimal notation. public static IPAddress CidrToMask(int cidr, AddressFamily family) { uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : NetworkConstants.MinimumIPv6PrefixSize) - cidr); addr = ((addr & 0xff000000) >> 24) | ((addr & 0x00ff0000) >> 8) | ((addr & 0x0000ff00) << 8) | ((addr & 0x000000ff) << 24); return new IPAddress(addr); } /// /// Convert a subnet mask to a CIDR. IPv4 only. /// https://stackoverflow.com/questions/36954345/get-cidr-from-netmask. /// /// Subnet mask. /// Byte CIDR representing the mask. public static byte MaskToCidr(IPAddress mask) { ArgumentNullException.ThrowIfNull(mask); byte cidrnet = 0; if (mask.Equals(IPAddress.Any)) { return cidrnet; } // GetAddressBytes Span bytes = stackalloc byte[mask.AddressFamily == AddressFamily.InterNetwork ? NetworkConstants.IPv4MaskBytes : NetworkConstants.IPv6MaskBytes]; if (!mask.TryWriteBytes(bytes, out var bytesWritten)) { Console.WriteLine("Unable to write address bytes, only ${bytesWritten} bytes written."); } var zeroed = false; for (var i = 0; i < bytes.Length; i++) { for (int v = bytes[i]; (v & 0xFF) != 0; v <<= 1) { if (zeroed) { // Invalid netmask. return (byte)~cidrnet; } if ((v & 0x80) == 0) { zeroed = true; } else { cidrnet++; } } } return cidrnet; } /// /// Converts an IPAddress into a string. /// IPv6 addresses are returned in [ ], with their scope removed. /// /// Address to convert. /// URI safe conversion of the address. public static string FormatIPString(IPAddress? address) { if (address is null) { return string.Empty; } var str = address.ToString(); if (address.AddressFamily == AddressFamily.InterNetworkV6) { int i = str.IndexOf('%', StringComparison.Ordinal); if (i != -1) { str = str.Substring(0, i); } return $"[{str}]"; } return str; } /// /// Try parsing an array of strings into objects, respecting exclusions. /// Elements without a subnet mask will be represented as with a single IP. /// /// Input string array to be parsed. /// Collection of . /// Boolean signaling if negated or not negated values should be parsed. /// True if parsing was successful. public static bool TryParseToSubnets(string[] values, [NotNullWhen(true)] out IReadOnlyList? result, bool negated = false) { if (values is null || values.Length == 0) { result = null; return false; } var tmpResult = new List(); for (int a = 0; a < values.Length; a++) { if (TryParseToSubnet(values[a], out var innerResult, negated)) { tmpResult.Add(innerResult); } } result = tmpResult; return tmpResult.Count > 0; } /// /// Try parsing a string into an , respecting exclusions. /// Inputs without a subnet mask will be represented as with a single IP. /// /// Input string to be parsed. /// An . /// Boolean signaling if negated or not negated values should be parsed. /// True if parsing was successful. public static bool TryParseToSubnet(ReadOnlySpan value, [NotNullWhen(true)] out IPNetwork? result, bool negated = false) { var splitString = value.Trim().Split('/'); if (splitString.MoveNext()) { var ipBlock = splitString.Current; var address = IPAddress.None; if (negated && ipBlock.StartsWith("!") && IPAddress.TryParse(ipBlock[1..], out var tmpAddress)) { address = tmpAddress; } else if (!negated && IPAddress.TryParse(ipBlock, out tmpAddress)) { address = tmpAddress; } if (address != IPAddress.None) { if (splitString.MoveNext()) { var subnetBlock = splitString.Current; if (int.TryParse(subnetBlock, out var netmask)) { result = new IPNetwork(address, netmask); return true; } else if (IPAddress.TryParse(subnetBlock, out var netmaskAddress)) { result = new IPNetwork(address, NetworkUtils.MaskToCidr(netmaskAddress)); return true; } } else if (address.AddressFamily == AddressFamily.InterNetwork) { result = address.Equals(IPAddress.Any) ? NetworkConstants.IPv4Any : new IPNetwork(address, NetworkConstants.MinimumIPv4PrefixSize); return true; } else if (address.AddressFamily == AddressFamily.InterNetworkV6) { result = address.Equals(IPAddress.IPv6Any) ? NetworkConstants.IPv6Any : new IPNetwork(address, NetworkConstants.MinimumIPv6PrefixSize); return true; } } } result = null; return false; } /// /// Attempts to parse a host span. /// /// Host name to parse. /// Object representing the span, if it has successfully been parsed. /// true if IPv4 is enabled. /// true if IPv6 is enabled. /// true if the parsing is successful, false if not. public static bool TryParseHost(ReadOnlySpan host, [NotNullWhen(true)] out IPAddress[]? addresses, bool isIPv4Enabled = true, bool isIPv6Enabled = false) { host = host.Trim(); if (host.IsEmpty) { addresses = null; return false; } // See if it's an IPv6 with port address e.g. [::1] or [::1]:120. if (host[0] == '[') { int i = host.IndexOf(']'); if (i != -1) { return TryParseHost(host[1..(i - 1)], out addresses); } addresses = Array.Empty(); return false; } var hosts = new List(); foreach (var splitSpan in host.Split(':')) { hosts.Add(splitSpan.ToString()); } if (hosts.Count <= 2) { var firstPart = hosts[0]; // Is hostname or hostname:port if (FqdnGeneratedRegex().IsMatch(firstPart)) { try { // .NET automatically filters only supported returned addresses based on OS support. addresses = Dns.GetHostAddresses(firstPart); return true; } catch (SocketException) { // Ignore socket errors, as the result value will just be an empty array. } } // Is an IPv4 or IPv4:port if (IPAddress.TryParse(firstPart.AsSpan().LeftPart('/'), out var address)) { if (((address.AddressFamily == AddressFamily.InterNetwork) && (!isIPv4Enabled && isIPv6Enabled)) || ((address.AddressFamily == AddressFamily.InterNetworkV6) && (isIPv4Enabled && !isIPv6Enabled))) { addresses = Array.Empty(); return false; } addresses = new[] { address }; // Host name is an IPv4 address, so fake resolve. return true; } } else if (hosts.Count > 0 && hosts.Count <= 9) // 8 octets + port { if (IPAddress.TryParse(host.LeftPart('/'), out var address)) { addresses = new[] { address }; return true; } } addresses = Array.Empty(); return false; } /// /// Gets the broadcast address for a . /// /// The . /// The broadcast address. public static IPAddress GetBroadcastAddress(IPNetwork network) { var addressBytes = network.BaseAddress.GetAddressBytes(); uint ipAddress = BitConverter.ToUInt32(addressBytes, 0); uint ipMaskV4 = BitConverter.ToUInt32(CidrToMask(network.PrefixLength, AddressFamily.InterNetwork).GetAddressBytes(), 0); uint broadCastIPAddress = ipAddress | ~ipMaskV4; return new IPAddress(BitConverter.GetBytes(broadCastIPAddress)); } }