< Summary - Jellyfin

Information
Class: MediaBrowser.Common.Net.NetworkUtils
Assembly: MediaBrowser.Common
File(s): /srv/git/jellyfin/MediaBrowser.Common/Net/NetworkUtils.cs
Line coverage
56%
Covered lines: 68
Uncovered lines: 52
Coverable lines: 120
Total lines: 360
Line coverage: 56.6%
Branch coverage
60%
Covered branches: 56
Total branches: 92
Branch coverage: 60.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100 10/25/2025 - 12:09:58 AM Line coverage: 56.3% (67/119) Branch coverage: 59% (52/88) Total lines: 3591/19/2026 - 12:13:54 AM Line coverage: 56.6% (68/120) Branch coverage: 60.8% (56/92) Total lines: 360 10/25/2025 - 12:09:58 AM Line coverage: 56.3% (67/119) Branch coverage: 59% (52/88) Total lines: 3591/19/2026 - 12:13:54 AM Line coverage: 56.6% (68/120) Branch coverage: 60.8% (56/92) Total lines: 360

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
IsIPv6LinkLocal(...)0%4260%
CidrToMask(...)0%620%
CidrToMask(...)0%620%
MaskToCidr(...)0%210140%
FormatIPString(...)33.33%12644.44%
TryParseToSubnets(...)100%1010100%
TryParseToSubnet(...)90%2020100%
TryParseHost(...)83.33%313088.23%
GetBroadcastAddress(...)100%210%
SubnetContainsAddress(...)50%2275%

File(s)

/srv/git/jellyfin/MediaBrowser.Common/Net/NetworkUtils.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Diagnostics.CodeAnalysis;
 4using System.Globalization;
 5using System.Net;
 6using System.Net.Sockets;
 7using System.Text.RegularExpressions;
 8using Jellyfin.Extensions;
 9using MediaBrowser.Model.Net;
 10
 11namespace MediaBrowser.Common.Net;
 12
 13/// <summary>
 14/// Defines the <see cref="NetworkUtils" />.
 15/// </summary>
 16public static partial class NetworkUtils
 17{
 18    // Use regular expression as CheckHostName isn't RFC5892 compliant.
 19    // Modified from gSkinner's expression at https://stackoverflow.com/questions/11809631/fully-qualified-domain-name-v
 20    [GeneratedRegex(@"(?im)^(?!:\/\/)(?=.{1,255}$)((.{1,63}\.){0,127}(?![0-9]*$)[a-z0-9-]+\.?)(:(\d){1,5}){0,1}$", Regex
 21    private static partial Regex FqdnGeneratedRegex();
 22
 23    /// <summary>
 24    /// Returns true if the IPAddress contains an IP6 Local link address.
 25    /// </summary>
 26    /// <param name="address">IPAddress object to check.</param>
 27    /// <returns>True if it is a local link address.</returns>
 28    /// <remarks>
 29    /// See https://stackoverflow.com/questions/6459928/explain-the-instance-properties-of-system-net-ipaddress
 30    /// it appears that the IPAddress.IsIPv6LinkLocal is out of date.
 31    /// </remarks>
 32    public static bool IsIPv6LinkLocal(IPAddress address)
 33    {
 034        ArgumentNullException.ThrowIfNull(address);
 35
 036        if (address.IsIPv4MappedToIPv6)
 37        {
 038            address = address.MapToIPv4();
 39        }
 40
 041        if (address.AddressFamily != AddressFamily.InterNetworkV6)
 42        {
 043            return false;
 44        }
 45
 46        // GetAddressBytes
 047        Span<byte> octet = stackalloc byte[16];
 048        address.TryWriteBytes(octet, out _);
 049        uint word = (uint)(octet[0] << 8) + octet[1];
 50
 051        return word >= 0xfe80 && word <= 0xfebf; // fe80::/10 :Local link.
 52    }
 53
 54    /// <summary>
 55    /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only.
 56    /// </summary>
 57    /// <param name="cidr">Subnet mask in CIDR notation.</param>
 58    /// <param name="family">IPv4 or IPv6 family.</param>
 59    /// <returns>String value of the subnet mask in dotted decimal notation.</returns>
 60    public static IPAddress CidrToMask(byte cidr, AddressFamily family)
 61    {
 062        uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : Netw
 063        addr = ((addr & 0xff000000) >> 24)
 064                | ((addr & 0x00ff0000) >> 8)
 065                | ((addr & 0x0000ff00) << 8)
 066                | ((addr & 0x000000ff) << 24);
 067        return new IPAddress(addr);
 68    }
 69
 70    /// <summary>
 71    /// Convert a subnet mask in CIDR notation to a dotted decimal string value. IPv4 only.
 72    /// </summary>
 73    /// <param name="cidr">Subnet mask in CIDR notation.</param>
 74    /// <param name="family">IPv4 or IPv6 family.</param>
 75    /// <returns>String value of the subnet mask in dotted decimal notation.</returns>
 76    public static IPAddress CidrToMask(int cidr, AddressFamily family)
 77    {
 078        uint addr = 0xFFFFFFFF << ((family == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : Netw
 079        addr = ((addr & 0xff000000) >> 24)
 080                | ((addr & 0x00ff0000) >> 8)
 081                | ((addr & 0x0000ff00) << 8)
 082                | ((addr & 0x000000ff) << 24);
 083        return new IPAddress(addr);
 84    }
 85
 86    /// <summary>
 87    /// Convert a subnet mask to a CIDR. IPv4 only.
 88    /// https://stackoverflow.com/questions/36954345/get-cidr-from-netmask.
 89    /// </summary>
 90    /// <param name="mask">Subnet mask.</param>
 91    /// <returns>Byte CIDR representing the mask.</returns>
 92    public static byte MaskToCidr(IPAddress mask)
 93    {
 094        ArgumentNullException.ThrowIfNull(mask);
 95
 096        byte cidrnet = 0;
 097        if (mask.Equals(IPAddress.Any))
 98        {
 099            return cidrnet;
 100        }
 101
 102        // GetAddressBytes
 0103        Span<byte> bytes = stackalloc byte[mask.AddressFamily == AddressFamily.InterNetwork ? NetworkConstants.IPv4MaskB
 0104        if (!mask.TryWriteBytes(bytes, out var bytesWritten))
 105        {
 0106            Console.WriteLine("Unable to write address bytes, only {0} bytes written.", bytesWritten.ToString(CultureInf
 107        }
 108
 0109        var zeroed = false;
 0110        for (var i = 0; i < bytes.Length; i++)
 111        {
 0112            for (int v = bytes[i]; (v & 0xFF) != 0; v <<= 1)
 113            {
 0114                if (zeroed)
 115                {
 116                    // Invalid netmask.
 0117                    return (byte)~cidrnet;
 118                }
 119
 0120                if ((v & 0x80) == 0)
 121                {
 0122                    zeroed = true;
 123                }
 124                else
 125                {
 0126                    cidrnet++;
 127                }
 128            }
 129        }
 130
 0131        return cidrnet;
 132    }
 133
 134    /// <summary>
 135    /// Converts an IPAddress into a string.
 136    /// IPv6 addresses are returned in [ ], with their scope removed.
 137    /// </summary>
 138    /// <param name="address">Address to convert.</param>
 139    /// <returns>URI safe conversion of the address.</returns>
 140    public static string FormatIPString(IPAddress? address)
 141    {
 17142        if (address is null)
 143        {
 0144            return string.Empty;
 145        }
 146
 17147        var str = address.ToString();
 17148        if (address.AddressFamily == AddressFamily.InterNetworkV6)
 149        {
 0150            int i = str.IndexOf('%', StringComparison.Ordinal);
 0151            if (i != -1)
 152            {
 0153                str = str.Substring(0, i);
 154            }
 155
 0156            return $"[{str}]";
 157        }
 158
 17159        return str;
 160    }
 161
 162    /// <summary>
 163    /// Try parsing an array of strings into <see cref="IPNetwork"/> objects, respecting exclusions.
 164    /// Elements without a subnet mask will be represented as <see cref="IPNetwork"/> with a single IP.
 165    /// </summary>
 166    /// <param name="values">Input string array to be parsed.</param>
 167    /// <param name="result">Collection of <see cref="IPNetwork"/>.</param>
 168    /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
 169    /// <returns><c>True</c> if parsing was successful.</returns>
 170    public static bool TryParseToSubnets(string[] values, [NotNullWhen(true)] out IReadOnlyList<IPData>? result, bool ne
 171    {
 164172        if (values is null || values.Length == 0)
 173        {
 96174            result = null;
 96175            return false;
 176        }
 177
 68178        List<IPData>? tmpResult = null;
 296179        for (int a = 0; a < values.Length; a++)
 180        {
 80181            if (TryParseToSubnet(values[a], out var innerResult, negated))
 182            {
 40183                (tmpResult ??= new()).Add(innerResult);
 184            }
 185        }
 186
 68187        result = tmpResult;
 68188        return result is not null;
 189    }
 190
 191    /// <summary>
 192    /// Try parsing a string into an <see cref="IPData"/>, respecting exclusions.
 193    /// Inputs without a subnet mask will be represented as <see cref="IPData"/> with a single IP.
 194    /// </summary>
 195    /// <param name="value">Input string to be parsed.</param>
 196    /// <param name="result">An <see cref="IPData"/>.</param>
 197    /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
 198    /// <returns><c>True</c> if parsing was successful.</returns>
 199    public static bool TryParseToSubnet(ReadOnlySpan<char> value, [NotNullWhen(true)] out IPData? result, bool negated =
 200    {
 201        // If multiple IP addresses are in a comma-separated string, the individual addresses may contain leading and/or
 249202        value = value.Trim();
 203
 249204        bool isAddressNegated = false;
 249205        if (value.StartsWith('!'))
 206        {
 19207            isAddressNegated = true;
 19208            value = value[1..]; // Remove leading '!' character
 209        }
 210
 249211        if (isAddressNegated != negated)
 212        {
 40213            result = default;
 40214            return false;
 215        }
 216
 209217        var index = value.IndexOf('/');
 209218        if (index != -1)
 219        {
 159220            if (IPAddress.TryParse(value[..index], out var address) && IPNetwork.TryParse(value, out var subnet))
 221            {
 159222                result = new IPData(address, subnet);
 159223                return true;
 224            }
 225        }
 50226        else if (IPAddress.TryParse(value, out var address))
 227        {
 24228            if (address.AddressFamily == AddressFamily.InterNetwork)
 229            {
 12230                result = address.Equals(IPAddress.Any) ? new IPData(IPAddress.Any, NetworkConstants.IPv4Any) : new IPDat
 12231                return true;
 232            }
 12233            else if (address.AddressFamily == AddressFamily.InterNetworkV6)
 234            {
 12235                result = address.Equals(IPAddress.IPv6Any) ? new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any) : n
 12236                return true;
 237            }
 238        }
 239
 26240        result = default;
 26241        return false;
 242    }
 243
 244    /// <summary>
 245    /// Attempts to parse a host span.
 246    /// </summary>
 247    /// <param name="host">Host name to parse.</param>
 248    /// <param name="addresses">Object representing the span, if it has successfully been parsed.</param>
 249    /// <param name="isIPv4Enabled"><c>true</c> if IPv4 is enabled.</param>
 250    /// <param name="isIPv6Enabled"><c>true</c> if IPv6 is enabled.</param>
 251    /// <returns><c>true</c> if the parsing is successful, <c>false</c> if not.</returns>
 252    public static bool TryParseHost(ReadOnlySpan<char> host, [NotNullWhen(true)] out IPAddress[]? addresses, bool isIPv4
 253    {
 261254        host = host.Trim();
 261255        if (host.IsEmpty)
 256        {
 5257            addresses = null;
 5258            return false;
 259        }
 260
 261        // See if it's an IPv6 with port address e.g. [::1] or [::1]:120.
 256262        if (host[0] == '[')
 263        {
 4264            int i = host.IndexOf(']');
 4265            if (i != -1)
 266            {
 4267                return TryParseHost(host[1..(i - 1)], out addresses);
 268            }
 269
 0270            addresses = Array.Empty<IPAddress>();
 0271            return false;
 272        }
 273
 252274        var hosts = new List<string>();
 2528275        foreach (var splitSpan in host.Split(':'))
 276        {
 1012277            hosts.Add(splitSpan.ToString());
 278        }
 279
 252280        if (hosts.Count <= 2)
 281        {
 143282            var firstPart = hosts[0];
 283
 284            // Is hostname or hostname:port
 143285            if (FqdnGeneratedRegex().IsMatch(firstPart))
 286            {
 287                try
 288                {
 289                    // .NET automatically filters only supported returned addresses based on OS support.
 15290                    addresses = Dns.GetHostAddresses(firstPart);
 12291                    return true;
 292                }
 3293                catch (SocketException)
 294                {
 295                    // Ignore socket errors, as the result value will just be an empty array.
 3296                }
 297            }
 298
 299            // Is an IPv4 or IPv4:port
 131300            if (IPAddress.TryParse(firstPart.AsSpan().LeftPart('/'), out var address))
 301            {
 123302                if (((address.AddressFamily == AddressFamily.InterNetwork) && (!isIPv4Enabled && isIPv6Enabled))
 123303                    || ((address.AddressFamily == AddressFamily.InterNetworkV6) && (isIPv4Enabled && !isIPv6Enabled)))
 304                {
 0305                    addresses = Array.Empty<IPAddress>();
 0306                    return false;
 307                }
 308
 123309                addresses = new[] { address };
 310
 311                // Host name is an IPv4 address, so fake resolve.
 123312                return true;
 313            }
 314        }
 109315        else if (hosts.Count > 0 && hosts.Count <= 9) // 8 octets + port
 316        {
 109317            if (IPAddress.TryParse(host.LeftPart('/'), out var address))
 318            {
 107319                addresses = new[] { address };
 107320                return true;
 321            }
 322        }
 323
 10324        addresses = Array.Empty<IPAddress>();
 10325        return false;
 12326    }
 327
 328    /// <summary>
 329    /// Gets the broadcast address for a <see cref="IPNetwork"/>.
 330    /// </summary>
 331    /// <param name="network">The <see cref="IPNetwork"/>.</param>
 332    /// <returns>The broadcast address.</returns>
 333    public static IPAddress GetBroadcastAddress(IPNetwork network)
 334    {
 0335        var addressBytes = network.BaseAddress.GetAddressBytes();
 0336        uint ipAddress = BitConverter.ToUInt32(addressBytes, 0);
 0337        uint ipMaskV4 = BitConverter.ToUInt32(CidrToMask(network.PrefixLength, AddressFamily.InterNetwork).GetAddressByt
 0338        uint broadCastIPAddress = ipAddress | ~ipMaskV4;
 339
 0340        return new IPAddress(BitConverter.GetBytes(broadCastIPAddress));
 341    }
 342
 343    /// <summary>
 344    /// Check if a subnet contains an address. This method also handles IPv4 mapped to IPv6 addresses.
 345    /// </summary>
 346    /// <param name="network">The <see cref="IPNetwork"/>.</param>
 347    /// <param name="address">The <see cref="IPAddress"/>.</param>
 348    /// <returns>Whether the supplied IP is in the supplied network.</returns>
 349    public static bool SubnetContainsAddress(IPNetwork network, IPAddress address)
 350    {
 34351        ArgumentNullException.ThrowIfNull(address);
 352
 34353        if (address.IsIPv4MappedToIPv6)
 354        {
 0355            address = address.MapToIPv4();
 356        }
 357
 34358        return network.Contains(address);
 359    }
 360}
Generated by: ReportGenerator 5.5.1.0
2/4/2026 - 12:13:54 AM
GitHub | reportgenerator.io

Methods/Properties

IsIPv6LinkLocal(System.Net.IPAddress)
CidrToMask(System.Byte,System.Net.Sockets.AddressFamily)
CidrToMask(System.Int32,System.Net.Sockets.AddressFamily)
MaskToCidr(System.Net.IPAddress)
FormatIPString(System.Net.IPAddress)
TryParseToSubnets(System.String[],System.Collections.Generic.IReadOnlyList`1<MediaBrowser.Model.Net.IPData>&,System.Boolean)
TryParseToSubnet(System.ReadOnlySpan`1<System.Char>,MediaBrowser.Model.Net.IPData&,System.Boolean)
TryParseHost(System.ReadOnlySpan`1<System.Char>,System.Net.IPAddress[]&,System.Boolean,System.Boolean)
GetBroadcastAddress(System.Net.IPNetwork)
SubnetContainsAddress(System.Net.IPNetwork,System.Net.IPAddress)