IPAddress

System\Net\IPAddress.cs (1)

771private sealed class ReadOnlyIPAddress : IPAddress

TestTransport\InMemoryHttpClientSlim.cs (1)

55address = new IPAddress(address.GetAddressBytes()); // Drop scope Id.

HttpClientSlim.cs (1)

54address = new IPAddress(address.GetAddressBytes()); // Drop scope Id.

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (2)

57return new IPAddress(bytes); // TODO: Does scope id matter? 63return new IPAddress(new byte[] { _buffer[4], _buffer[5], _buffer[6], _buffer[7] });

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (2)

57return new IPAddress(bytes); // TODO: Does scope id matter? 63return new IPAddress(new byte[] { _buffer[4], _buffer[5], _buffer[6], _buffer[7] });

KestrelServerTests.cs (2)

1000resolvedEndPoint = new IPEndPoint(new IPAddress(ipEndPoint.Address.GetAddressBytes()), port); 1052resolvedEndPoint = new IPEndPoint(new IPAddress(ipEndPoint.Address.GetAddressBytes()), port);

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (2)

57return new IPAddress(bytes); // TODO: Does scope id matter? 63return new IPAddress(new byte[] { _buffer[4], _buffer[5], _buffer[6], _buffer[7] });

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (1)

214builder.Host = new IPAddress(ip.GetAddressBytes()).ToString(); // Without the scope id.

src\libraries\Common\src\System\Net\InteropIPAddressExtensions.Unix.cs (2)

32return new IPAddress((long)address); 36return new IPAddress(

System\Net\NetworkInformation\IPAddressUtil.cs (1)

37IPAddress ipAddress = new IPAddress(new ReadOnlySpan<byte>(addressInfo->AddressBytes, addressInfo->NumAddressBytes));

System\Net\NetworkInformation\LinuxNetworkInterface.cs (1)

116var address = new IPAddress(new ReadOnlySpan<byte>(ai->AddressBytes, ai->NumAddressBytes));

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (1)

29IPAddress address = new IPAddress(addressValue);

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (2)

346ipAddress = new IPAddress(addressValue); 384IPAddress ipAddress = new IPAddress(addressBytes);

System\Net\NetworkInformation\UnicastIPAddressInformation.cs (1)

88return new IPAddress(addressBytes);

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

22return new IPAddress(address, (address[0] == 0xFE && (address[1] & 0xC0) == 0x80) ? (long)scope : 0); 26return new IPAddress((long)SocketAddressPal.GetIPv4Address(socketAddressBuffer) & 0x0FFFFFFFF);

System\Net\NetworkInformation\Ping.cs (2)

110new IPAddress(address.Address) : 112new IPAddress(address.GetAddressBytes(), address.ScopeId);

System\Net\NetworkInformation\Ping.PingUtility.cs (1)

146address = new IPAddress(0);

System\Net\NetworkInformation\Ping.RawSocket.cs (1)

391return new PingReply(address ?? new IPAddress(0), null, status, rtt, Array.Empty<byte>());

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

22return new IPAddress(address, (address[0] == 0xFE && (address[1] & 0xC0) == 0x80) ? (long)scope : 0); 26return new IPAddress((long)SocketAddressPal.GetIPv4Address(socketAddressBuffer) & 0x0FFFFFFFF);

System\Net\IPAddress.cs (2)

748return new IPAddress(labels, 0); 762return new IPAddress((uint)HostToNetworkOrder(unchecked((int)address)));

System\Net\IPAddressParser.cs (2)

50return new IPAddress(numbers, scope); 55return new IPAddress(address);

System\Net\IPEndPoint.cs (1)

41_address = new IPAddress(address);

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

22return new IPAddress(address, (address[0] == 0xFE && (address[1] & 0xC0) == 0x80) ? (long)scope : 0); 26return new IPAddress((long)SocketAddressPal.GetIPv4Address(socketAddressBuffer) & 0x0FFFFFFFF);

src\libraries\Common\src\System\Net\InteropIPAddressExtensions.Unix.cs (2)

32return new IPAddress((long)address); 36return new IPAddress(

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

22return new IPAddress(address, (address[0] == 0xFE && (address[1] & 0xC0) == 0x80) ? (long)scope : 0); 26return new IPAddress((long)SocketAddressPal.GetIPv4Address(socketAddressBuffer) & 0x0FFFFFFFF);

System\Net\Sockets\Socket.cs (4)

159new IPAddress((long)SocketAddressPal.GetIPv4Address(buffer.Slice(0, bufferLength)) & 0x0FFFFFFFF), 167new IPAddress(address, scope), 193new IPAddress((long)SocketAddressPal.GetIPv4Address(buffer.Slice(0, bufferLength)) & 0x0FFFFFFFF), 201new IPAddress(address, scope),

System\Net\Sockets\SocketPal.Unix.cs (2)

1719var multicastAddress = new IPAddress((long)opt.MulticastAddress); 1720var localAddress = new IPAddress((long)opt.LocalAddress);

System\Security\Cryptography\X509Certificates\X509SubjectAlternativeNameExtension.cs (1)

73yield return new IPAddress(value);

MS\Internal\AutomationProxies\WindowsIPAddress.cs (1)

236return new IPAddress ((long) ipV4);

DashboardWebApplication.cs (2)

866return host == "*" || host == "+" || host == IPAddress.Any.ToString() || host == IPAddress.IPv6Any.ToString();

Integration\DashboardClientAuthTests.cs (1)

95kestrelOptions.Listen(IPAddress.Loopback, port: 0, ConfigureListen);

Integration\MockOpenIdAuthority.cs (1)

31options.Listen(IPAddress.Loopback, 0);

Integration\StartupTests.cs (2)

720Assert.True(ipEndPoint.Address.Equals(IPAddress.Any) || ipEndPoint.Address.Equals(IPAddress.IPv6Any), "Endpoint address should be IPv4 or IPv6.");

Dashboard\DashboardServiceHost.cs (1)

146kestrelOptions.Listen(IPAddress.Loopback, port: 0, ConfigureListen);

Program.cs (1)

58options.Listen(IPAddress.Loopback, uri.Port, listenOptions =>

Tcp\TcpHubConnectionBuilderExtensions.cs (2)

28endPoint = new IPEndPoint(IPAddress.Loopback, uri.Port); 32endPoint = new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\CoreClrSocketConnection.cs (2)

921protected override IConnection CreateConnection(IPAddress address, int port) 938protected override async Task<IConnection> CreateConnectionAsync(IPAddress address, int port)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\DnsCache.cs (6)

75public static async Task<IPAddress[]> ResolveAsync(Uri uri) 78IPAddress[] hostAddresses = null; 166internal static async Task<IPAddress[]> LookupHostName(string hostName) 175private IPAddress[] _addressList; 177public DnsCacheEntry(IPAddress[] addressList, DateTime timeStamp) 183public IPAddress[] AddressList

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\SocketConnection.cs (10)

431protected abstract IConnection CreateConnection(IPAddress address, int port); 433protected abstract Task<IConnection> CreateConnectionAsync(IPAddress address, int port); 482private static async Task<IPAddress[]> GetIPAddressesAsync(Uri uri) 487IPAddress ipAddress = IPAddress.Parse(uri.DnsSafeHost); 488return new IPAddress[] { ipAddress }; 491IPAddress[] addresses = null; 512private static TimeoutException CreateTimeoutException(Uri uri, TimeSpan timeout, IPAddress[] addresses, int invalidAddressCount, 538IPAddress[] addresses = SocketConnectionInitiator.GetIPAddressesAsync(uri).GetAwaiter().GetResult(); 590IPAddress[] addresses = await SocketConnectionInitiator.GetIPAddressesAsync(uri);

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

Program.cs (1)

45options.Listen(IPAddress.Any, 5001, listenOptions =>

Program.cs (2)

33connection.RemoteIpAddress = IPAddress.IPv6Loopback; 35connection.LocalIpAddress = IPAddress.IPv6Loopback;

Startup.cs (2)

52options.Listen(new IPEndPoint(IPAddress.Loopback, 5001), listenOptions => 56options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), listenOptions =>

TestConnections.cs (3)

246var address = addressFamily == AddressFamily.InterNetworkV6 247? IPAddress.IPv6Loopback 248: IPAddress.Loopback;

src\Servers\IIS\IIS\test\Common.FunctionalTests\AspNetCorePortTests.cs (1)

165socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (1)

1454socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (1)

1454socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (1)

1454socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

src\Servers\IIS\IIS\test\Common.FunctionalTests\AspNetCorePortTests.cs (1)

165socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (1)

1454socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

ConnectionLimitTests.cs (1)

237var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0));

ConnectionMiddlewareTests.cs (8)

HttpProtocolSelectionTests.cs (2)

62var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) 81var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))

KestrelMetricsTests.cs (5)

46var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 109var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 323var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 441var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 493var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0));

ResponseDrainingTests.cs (2)

17new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)), 18new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)).UsePassThrough()

ResponseTests.cs (8)

src\Servers\Kestrel\shared\test\CertHelper.cs (1)

50listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));

src\Servers\Kestrel\shared\test\TestConnection.cs (3)

66var address = addressFamily == AddressFamily.InterNetworkV6 67? IPAddress.IPv6Loopback 68: IPAddress.Loopback;

TestTransport\InMemoryHttpClientSlim.cs (2)

54var address = IPAddress.Parse(requestUri.Host);

TestTransport\InMemoryTransportConnection.cs (2)

29LocalEndPoint = new IPEndPoint(IPAddress.Loopback, 0); 30RemoteEndPoint = new IPEndPoint(IPAddress.Loopback, 0);

TestTransport\TestServer.cs (2)

44: this(app, context, new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))) 57var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (6)

367Assert.True(IPAddress.IsLoopback(ctx.Connection.LocalIpAddress)); 368ctx.Connection.LocalIpAddress = IPAddress.IPv6Any; 369Assert.Equal(IPAddress.IPv6Any, ctx.Connection.LocalIpAddress); 371Assert.True(IPAddress.IsLoopback(ctx.Connection.RemoteIpAddress)); 372ctx.Connection.RemoteIpAddress = IPAddress.IPv6Any; 373Assert.Equal(IPAddress.IPv6Any, ctx.Connection.RemoteIpAddress);

H2SpecTests.cs (1)

36options.Listen(IPAddress.Loopback, 0, listenOptions =>

Http2\Http2RequestTests.cs (2)

68socket.Connect(IPAddress.Loopback, host.GetPort()); 106o.Listen(IPAddress.IPv6Loopback, 0, listenOptions =>

Http2WebSocketInteropTests.cs (1)

178options.Listen(IPAddress.Loopback, 0, listenOptions =>

Http3\Http3RequestTests.cs (7)

898o.Listen(IPAddress.Parse("127.0.0.1"), port, listenOptions => 1219o.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 1691kestrel.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 1860kestrel.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 1938IPAddress remoteAddress = null; 1940IPAddress localAddress = null; 2023kestrel.Listen(IPAddress.Loopback, 0, listenOptions =>

HttpClientHttp2InteropTests.cs (3)

1606options.Listen(IPAddress.Loopback, 0, listenOptions => 1651options.Listen(IPAddress.Loopback, 0, listenOptions => 1710options.Listen(IPAddress.Loopback, 0, listenOptions =>

HttpHelpers.cs (1)

76o.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions =>

Startup.cs (3)

98options.Listen(IPAddress.Loopback, basePort, listenOptions => 106options.Listen(IPAddress.Loopback, basePort + 1, listenOptions => 148.Endpoint(IPAddress.Loopback, basePort + 6)

Startup.cs (1)

49options.Listen(IPAddress.Loopback, 5001);

KeyManagement\KeyRingBasedDataProtectorTests.cs (1)

625.Concat(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(purposes.Length))); // purposeCount

Infrastructure\TestHelpers.cs (1)

30httpContext.Connection.RemoteIpAddress = IPAddress.Parse("127.0.0.1");

JsonTranscodingServerCallContextTests.cs (1)

67httpContext.Connection.RemoteIpAddress = IPAddress.Parse("127.0.0.1");

CommonHeaders.cs (1)

100public static HeaderSetup<IReadOnlyList<IPAddress>> XForwardedFor => new("X-Forwarded-For", IPAddressListParser.Instance);

Parsers\IPAddressListParser.cs (5)

12internal sealed class IPAddressListParser : HeaderParser<IReadOnlyList<IPAddress>> 16public override bool TryParse(StringValues values, [NotNullWhen(true)] out IReadOnlyList<IPAddress>? result, [NotNullWhen(false)] out string? error) 18var list = new List<IPAddress>(); 43if (IPAddress.TryParse(addressToParse, out var address))

HeaderKeyTests.cs (1)

38var referenceTimeDefault = new HeaderKey<IReadOnlyList<IPAddress>>(TestHeaderName, IPAddressListParser.Instance, TestHeaderPosition);

ParserTests.cs (12)

372Assert.Equal(new List<IPAddress> { IPAddress.Parse("1.1.1.1"), IPAddress.Parse("192.168.1.100"), IPAddress.Parse("3.3.3.3") }, result); 382Assert.Equal(new List<IPAddress> { IPAddress.Parse("1.1.1.1"), IPAddress.Parse("192.168.1.100"), IPAddress.Parse("3.3.3.3") }, result); 394Assert.Equal(new List<IPAddress> { IPAddress.Parse("1.1.1.1") }, result); 406Assert.Equal(new List<IPAddress> { IPAddress.Parse("1::ffff") }, result);

Features\HttpConnectionFeature.cs (2)

17public IPAddress? LocalIpAddress { get; set; } 23public IPAddress? RemoteIpAddress { get; set; }

Internal\DefaultConnectionInfo.cs (2)

56public override IPAddress? RemoteIpAddress 68public override IPAddress? LocalIpAddress

ConnectionInfo.cs (4)

28public abstract IPAddress? RemoteIpAddress { get; set; } 38public abstract IPAddress? LocalIpAddress { get; set; } 81public IPAddress? RemoteIpAddress => _info.RemoteIpAddress; 83public IPAddress? LocalIpAddress => _info.LocalIpAddress;

HttpConnectionDispatcherTests.cs (4)

777context.Connection.LocalIpAddress = IPAddress.Loopback; 779context.Connection.RemoteIpAddress = IPAddress.IPv6Any; 826Assert.Equal(IPAddress.Loopback, connectionHttpContext.Connection.LocalIpAddress); 828Assert.Equal(IPAddress.IPv6Any, connectionHttpContext.Connection.RemoteIpAddress);

RequestDelegateFactoryTests.cs (6)

332new object[] { (Action<HttpContext, IPAddress[]>)Store, new[] { "127.0.0.1" }, new[] { IPAddress.Loopback } }, 333new object[] { (Action<HttpContext, IPEndPoint[]>)Store, new[] { "127.0.0.1:80" },new[] { new IPEndPoint(IPAddress.Loopback, 80) } }, 383new object[] { (Action<HttpContext, IPAddress>)Store, "127.0.0.1", IPAddress.Loopback }, 384new object[] { (Action<HttpContext, IPEndPoint>)Store, "127.0.0.1:80", new IPEndPoint(IPAddress.Loopback, 80) },

RequestDelegateGenerator\RequestDelegateCreationTests.Arrays.cs (2)

139new object[] { "IPAddress[]", new[] { "127.0.0.1" }, new[] { IPAddress.Loopback } }, 140new object[] { "IPEndPoint[]", new[] { "127.0.0.1:80" },new[] { new IPEndPoint(IPAddress.Loopback, 80) } },

RequestDelegateGenerator\RequestDelegateCreationTests.TryParse.cs (2)

50new object[] { "IPAddress", "127.0.0.1", IPAddress.Loopback }, 51new object[] { "IPEndPoint", "127.0.0.1:80", new IPEndPoint(IPAddress.Loopback, 80) },

IHttpConnectionFeature.cs (2)

21IPAddress? RemoteIpAddress { get; set; } 26IPAddress? LocalIpAddress { get; set; }

ForwardedHeadersMiddleware.cs (2)

388private bool CheckKnownAddress(IPAddress address) 392var ipv4Address = address.MapToIPv4();

ForwardedHeadersOptions.cs (5)

5using IPAddress = System.Net.IPAddress; 81public IList<IPAddress> KnownProxies { get; } = new List<IPAddress>() { IPAddress.IPv6Loopback }; 86public IList<IPNetwork> KnownNetworks { get; } = new List<IPNetwork>() { new IPNetwork(IPAddress.Loopback, 8) };

IPNetwork.cs (17)

16/// Create a new <see cref="IPNetwork"/> with the specified <see cref="IPAddress"/> and prefix length. 18/// <param name="prefix">The <see cref="IPAddress"/>.</param> 21public IPNetwork(IPAddress prefix, int prefixLength) : this(prefix, prefixLength, true) 25private IPNetwork(IPAddress prefix, int prefixLength, bool checkPrefixLengthRange) 40/// Get the <see cref="IPAddress"/> that represents the prefix for the network. 42public IPAddress Prefix { get; } 54/// Determine whether a given The <see cref="IPAddress"/> is part of the IP network. 56/// <param name="address">The <see cref="IPAddress"/>.</param> 57/// <returns><see langword="true"/> if the <see cref="IPAddress"/> is part of the IP network. Otherwise, <see langword="false"/>.</returns> 58public bool Contains(IPAddress address) 96private static bool IsValidPrefixLengthRange(IPAddress prefix, int prefixLength) 121/// <inheritdoc cref="TryParseComponents(ReadOnlySpan{char}, out IPAddress?, out int)"/> 124if (!TryParseComponents(networkSpan, out var prefix, out var prefixLength)) 152/// <inheritdoc cref="TryParseComponents(ReadOnlySpan{char}, out IPAddress?, out int)"/> 157if (!TryParseComponents(networkSpan, out var prefix, out var prefixLength)) 182[NotNullWhen(true)] out IPAddress? prefix, 194if (!IPAddress.TryParse(networkSpan.Slice(0, forwardSlashIndex), out prefix))

ForwardedHeadersMiddlewareTest.cs (12)

77c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 135c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 173c.Connection.RemoteIpAddress = IPAddress.Parse(originalIp); 182Assert.Equal(new IPEndPoint(IPAddress.Parse(originalIp), 99).ToString(), 231foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text))) 246c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 879c.Connection.RemoteIpAddress = IPAddress.Parse(remoteIp); 1014var proxy = IPAddress.Parse(knownProxy); 1020var networkIp = IPAddress.Parse(knownNetworkParts[0]);

IPNetworkTest.cs (8)

25var network = new IPNetwork(IPAddress.Parse(prefixText), length); 26Assert.True(network.Contains(IPAddress.Parse(addressText))); 39var network = new IPNetwork(IPAddress.Parse(prefixText), length); 40Assert.False(network.Contains(IPAddress.Parse(addressText))); 51var address = IPAddress.Parse(prefixText); 69var address = IPAddress.Parse(prefixText);

src\Identity\Extensions.Core\src\Rfc6238AuthenticationService.cs (1)

39var res = BitConverter.TryWriteBytes(timestepAsBytes, IPAddress.HostToNetworkOrder((long)timestepNumber));

HttpClientSlim.cs (2)

53var address = IPAddress.Parse(requestUri.Host);

OwinEnvironment.cs (2)

86(feature, value) => feature.LocalIpAddress = IPAddress.Parse(Convert.ToString(value, CultureInfo.InvariantCulture))) }, 88(feature, value) => feature.RemoteIpAddress = IPAddress.Parse(Convert.ToString(value, CultureInfo.InvariantCulture))) },

OwinFeatureCollection.cs (4)

199IPAddress IHttpConnectionFeature.RemoteIpAddress 201get { return IPAddress.Parse(Prop<string>(OwinConstants.CommonKeys.RemoteIpAddress)); } 205IPAddress IHttpConnectionFeature.LocalIpAddress 207get { return IPAddress.Parse(Prop<string>(OwinConstants.CommonKeys.LocalIpAddress)); }

PatternSegments\IsIPV6SegmentTests.cs (2)

33context.HttpContext.Connection.RemoteIpAddress = IPAddress.Parse("2001:0db8:85a3:0000:0000:8a2e:0370:7334"); 48context.HttpContext.Connection.RemoteIpAddress = IPAddress.Parse("20.30.40.50");

PatternSegments\LocalAddressSegmentTests.cs (1)

18context.HttpContext.Connection.LocalIpAddress = IPAddress.Parse("20.30.40.50");

PatternSegments\RemoteAddressSegmentTests.cs (1)

18context.HttpContext.Connection.RemoteIpAddress = IPAddress.Parse("20.30.40.50");

RequestProcessing\Request.cs (2)

321public IPAddress? RemoteIpAddress => RemoteEndPoint.GetIPAddress(); 323public IPAddress? LocalIpAddress => LocalEndPoint.GetIPAddress();

RequestProcessing\RequestContext.FeatureCollection.cs (4)

53private IPAddress? _remoteIpAddress; 54private IPAddress? _localIpAddress; 236IPAddress? IHttpConnectionFeature.LocalIpAddress 254IPAddress? IHttpConnectionFeature.RemoteIpAddress

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (3)

36internal IPAddress? GetIPAddress() 52private IPAddress GetIpv6Address() 60private IPAddress GetIPv4Address()

RequestTests.cs (4)

101connectionInfo.RemoteIpAddress = IPAddress.Broadcast; 102Assert.Equal(IPAddress.Broadcast, connectionInfo.RemoteIpAddress); 105connectionInfo.LocalIpAddress = IPAddress.Any; 106Assert.Equal(IPAddress.Any, connectionInfo.LocalIpAddress);

src\Shared\Http2cat\Http2CatHostedService.cs (2)

61if (!IPAddress.TryParse(address.Host, out var ip))

Core\IISHttpContext.cs (2)

106public IPAddress? RemoteIpAddress { get; set; } 108public IPAddress? LocalIpAddress { get; set; }

Core\IISHttpContext.IHttpConnectionFeature.cs (2)

13IPAddress? IHttpConnectionFeature.RemoteIpAddress 27IPAddress? IHttpConnectionFeature.LocalIpAddress

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (3)

36internal IPAddress? GetIPAddress() 52private IPAddress GetIpv6Address() 60private IPAddress GetIPv4Address()

Common\TestPortHelper.cs (2)

26socket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); 44socket.Bind(new IPEndPoint(IPAddress.Loopback, port));

Deployers\NginxDeployer.cs (1)

46_portSelector.Bind(new IPEndPoint(IPAddress.Loopback, 0));

AnyIPListenOptions.cs (2)

14: base(new IPEndPoint(IPAddress.IPv6Any, port)) 41EndPoint = new IPEndPoint(IPAddress.Any, IPEndPoint.Port);

Internal\AddressBinder.cs (2)

76if (!IPAddress.TryParse(address.Host, out var ip))

Internal\Http\HttpProtocol.cs (2)

142public IPAddress? RemoteIpAddress { get; set; } 144public IPAddress? LocalIpAddress { get; set; }

Internal\Http\HttpProtocol.FeatureCollection.cs (2)

156IPAddress? IHttpConnectionFeature.RemoteIpAddress 162IPAddress? IHttpConnectionFeature.LocalIpAddress

KestrelConfigurationLoader.cs (2)

94public KestrelConfigurationLoader Endpoint(IPAddress address, int port) => Endpoint(address, port, _ => { }); 99public KestrelConfigurationLoader Endpoint(IPAddress address, int port, Action<ListenOptions> configure)

KestrelServerOptions.cs (2)

472public void Listen(IPAddress address, int port) 481public void Listen(IPAddress address, int port, Action<ListenOptions> configure)

ListenOptions.cs (1)

234protected internal ListenOptions Clone(IPAddress address)

LocalhostListenOptions.cs (3)

13: base(new IPEndPoint(IPAddress.Loopback, port)) 35var v4Options = Clone(IPAddress.Loopback); 49var v6Options = Clone(IPAddress.IPv6Loopback);

AddressBinderTests.cs (6)

31Assert.Equal(IPAddress.Parse(expectedAddress), endpoint.Address); 59Assert.Equal(IPAddress.IPv6Any, listenOptions.IPEndPoint.Address); 70Assert.Equal(IPAddress.Loopback, listenOptions.IPEndPoint.Address); 150Assert.Equal(IPAddress.Parse(ip), listenOptions.IPEndPoint.Address); 267if (endpoint.IPEndPoint.Address.Equals(IPAddress.IPv6Any)) 273if (endpoint.IPEndPoint.Address.Equals(IPAddress.Any))

KestrelServerOptionsTests.cs (1)

38options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), opt =>

KestrelServerTests.cs (28)

ListenOptionsTests.cs (4)

18var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 38var clone = localhostListenOptions.Clone(IPAddress.IPv6Loopback); 56var clone1 = localhostListenOptions.Clone(IPAddress.IPv6Loopback); 63var clone2 = localhostListenOptions.Clone(IPAddress.IPv6Loopback);

src\Servers\Kestrel\shared\test\CertHelper.cs (1)

50listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));

src\Servers\Kestrel\shared\test\TestConnection.cs (3)

66var address = addressFamily == AddressFamily.InterNetworkV6 67? IPAddress.IPv6Loopback 68: IPAddress.Loopback;

QuicConnectionListenerTests.cs (1)

288var endpoint = new IPEndPoint(IPAddress.Loopback, 0);

QuicTestHelpers.cs (2)

59var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port); 73var endpoint = new IPEndPoint(IPAddress.Loopback, port);

WebHostTests.cs (6)

109o.Listen(IPAddress.Parse("127.0.0.1"), http3Port, listenOptions => 114o.Listen(IPAddress.Parse("127.0.0.1"), http1Port, listenOptions => 149o.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 186o.Listen(IPAddress.Parse("127.0.0.1"), port, listenOptions => 224o.Listen(IPAddress.Parse("127.0.0.1"), port, listenOptions => 295o.Listen(IPAddress.Parse("127.0.0.1"), port, listenOptions =>

SocketTransportOptions.cs (1)

146if (ip.Address.Equals(IPAddress.IPv6Any))

src\Shared\HttpSys\NativeInterop\SocketAddress.cs (3)

36internal IPAddress? GetIPAddress() 52private IPAddress GetIpv6Address() 60private IPAddress GetIPv4Address()

HttpConnectionFactoryTests.cs (1)

53var ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await factory.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 0)));

RedisOptions.cs (1)

38Configuration.EndPoints.Add(IPAddress.Loopback, 0);

TestConnectionMultiplexer.cs (1)

147public IServer GetServer(IPAddress host, int port)

Util\TcpPortFinder.cs (1)

13var listener = new TcpListener(IPAddress.Loopback, 0);

StaticFileMiddlewareTests.cs (1)

303socket.Connect(IPAddress.Loopback, uri.Port);

ClientHandlerTests.cs (2)

267Assert.Equal(IPAddress.Parse("1.1.1.1"), features.Get<IHttpConnectionFeature>().RemoteIpAddress); 270context.Connection.RemoteIpAddress = IPAddress.Parse("1.1.1.1");

ServiceFakesWebHostExtensions.cs (2)

36.UseKestrel(options => options.Listen(new IPEndPoint(IPAddress.Loopback, 0))); 53options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions =>

KestrelWebSocketHelpers.cs (1)

66options.Listen(IPAddress.Loopback, 0);

Utils.cs (6)

133int timeLow = IPAddress.HostToNetworkOrder(BitConverter.ToInt32(namespaceBytes, 0)); 135short timeMid = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 4)); 137short timeHiVersion = IPAddress.HostToNetworkOrder(BitConverter.ToInt16(namespaceBytes, 6)); 158timeLow = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(hash, 0)); 162timeMid = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 4)); 166timeHiVersion = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(hash, 6));

TcpEndpointProbesService.cs (1)

36_listener = new TcpListener(IPAddress.Any, _options.TcpPort);

TcpEndpointProbesServiceTests.cs (2)

103tcpClient.Connect(new IPEndPoint(IPAddress.Loopback, port)); 123var listener = new TcpListener(IPAddress.Loopback, 0);

ResourceMonitoringOptionsCustomValidator.cs (2)

25if (!IPAddress.TryParse(s, out var ipAddress)

Windows\Network\WindowsTcpStateInfo.cs (6)

32.Where(ip => IPAddress.TryParse(ip, out var ipAddress) && ipAddress.AddressFamily == AddressFamily.InterNetwork) 34.Select(s => (uint)IPAddress.Parse(s).Address) 38.Where(ip => IPAddress.TryParse(ip, out var ipAddress) && ipAddress.AddressFamily == AddressFamily.InterNetworkV6) 39.Select(s => IPAddress.Parse(s).GetAddressBytes())

Rfc6238AuthenticationService.cs (1)

42var timestepAsBytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((long)timestepNumber));

Configuration\ConfigurationServiceEndpointProvider.cs (2)

207if (IPAddress.TryParse(uri.Host, out var ip))

PassThrough\PassThroughServiceEndpointProviderFactory.cs (2)

51if (IPAddress.TryParse(host, out var ip))

DnsSrvServiceEndpointResolverTests.cs (24)

ConfigurationServiceEndpointResolverTests.cs (2)

371Assert.Equal(new IPEndPoint(IPAddress.Loopback, 3333), initialResult.EndpointSource.Endpoints[1].EndPoint); 418Assert.Equal(new IPEndPoint(IPAddress.Loopback, 3333), initialResult.EndpointSource.Endpoints[1].EndPoint);

ServiceEndpointResolverTests.cs (13)

YarpServiceDiscoveryTests.cs (19)

LogPropertiesTests.cs (3)

96P6 = IPAddress.Parse("192.168.10.1"), 97P7 = new IPEndPoint(IPAddress.Parse("192.168.10.1"), 42), 98P8 = new IPEndPoint(IPAddress.Parse("192.168.10.1"), 42),

test\Generators\Microsoft.Gen.Logging\TestClasses\LogPropertiesSpecialTypesExtensions.cs (1)

21public IPAddress? P6 { get; set; }

netstandard.cs (1)

1158[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Net.IPAddress))]

Startup.cs (1)

44options.Listen(IPAddress.Loopback, 5001);

Startup.cs (2)

48options.Listen(IPAddress.Loopback, 5000); 49options.Listen(IPAddress.Loopback, 5001, listenOptions =>

SocketTransportOptionsTests.cs (3)

86yield return new object[] { new IPEndPoint(IPAddress.Loopback, 0) }; 88yield return new object[] { new IPEndPoint(IPAddress.IPv6Loopback, 0) }; 107fileHandleSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0));

src\Servers\Kestrel\shared\test\TestConnection.cs (3)

66var address = addressFamily == AddressFamily.InterNetworkV6 67? IPAddress.IPv6Loopback 68: IPAddress.Loopback;

src\Servers\Kestrel\shared\test\TransportTestHelpers\IPv6SupportedConditionAttribute.cs (1)

26socket.Bind(new IPEndPoint(IPAddress.IPv6Loopback, 0));

src\Servers\Kestrel\shared\test\TransportTestHelpers\TestServer.cs (2)

42: this(app, context, new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))) 54var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (55)

src\Servers\Kestrel\shared\test\TestConnection.cs (3)

66var address = addressFamily == AddressFamily.InterNetworkV6 67? IPAddress.IPv6Loopback 68: IPAddress.Loopback;

src\Servers\Kestrel\shared\test\TransportTestHelpers\IPv6SupportedConditionAttribute.cs (1)

26socket.Bind(new IPEndPoint(IPAddress.IPv6Loopback, 0));

src\Servers\Kestrel\shared\test\TransportTestHelpers\TestServer.cs (2)

42: this(app, context, new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))) 54var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))

src\Servers\Kestrel\test\FunctionalTests\ConnectionMiddlewareTests.cs (2)

21var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 51var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0));

src\Servers\Kestrel\test\FunctionalTests\Http2\HandshakeTests.cs (3)

54kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions => 80kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions => 108kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions =>

src\Servers\Kestrel\test\FunctionalTests\Http2\ShutdownTests.cs (3)

78kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions => 135kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions => 186kestrelOptions.Listen(IPAddress.Loopback, 0, listenOptions =>

src\Servers\Kestrel\test\FunctionalTests\ListenHandleTests.cs (1)

34_canListenToOpenTcpSocketHandleSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0));

src\Servers\Kestrel\test\FunctionalTests\MaxRequestBufferSizeTests.cs (2)

317options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions => 384socket.Connect(IPAddress.Loopback, port);

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (6)

51{ "Loopback", () => new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)) }, 52{ "PassThrough", () => new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)).UsePassThrough() } 118socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort())); 570socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort())); 617socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort())); 711socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort()));

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (5)

38new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)), 39new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)).UsePassThrough() 878var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 955var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0)); 1042var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0));

src\libraries\shims\System\ref\System.cs (1)

643[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Net.IPAddress))]

System.Net.cs (1)

19[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Net.IPAddress))]

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (6)

156if (IPAddress.TryParse(host, out IPAddress? hostIP)) 229IPAddress? ipv4Address = null; 230if (IPAddress.TryParse(host, out IPAddress? hostIP)) 248IPAddress[] addresses;

System\Net\Managed\HttpEndPointListener.cs (1)

52public HttpEndPointListener(HttpListener listener, IPAddress addr, int port, bool secure)

System\Net\Managed\HttpEndPointManager.cs (5)

40private static readonly Dictionary<IPAddress, Dictionary<int, HttpEndPointListener>> s_ipEndPoints = new Dictionary<IPAddress, Dictionary<int, HttpEndPointListener>>(); 112IPAddress addr; 115addr = IPAddress.Any; 130if (IPAddress.Any.Equals(addr))

System\Net\Managed\HttpListener.Certificates.cs (1)

20internal static X509Certificate? LoadCertificateAndKey(IPAddress addr, int port)

System\Net\Managed\ListenerPrefix.cs (2)

44private IPAddress[]? _addresses; 58public IPAddress[]? Addresses

System\Net\ServiceNameStore.cs (1)

275IPAddress.IsValid(hostname))

src\libraries\Common\src\System\Net\InteropIPAddressExtensions.Unix.cs (2)

11public static unsafe Interop.Sys.IPAddress GetNativeIPAddress(this IPAddress ipAddress) 27public static unsafe IPAddress GetIPAddress(this Interop.Sys.IPAddress nativeIPAddress)

System\Net\Dns.cs (65)

System\Net\IPHostEntry.cs (1)

24public IPAddress[] AddressList { get; set; }

System\Net\NameResolutionPal.Unix.cs (7)

55private static unsafe void ParseHostEntry(Interop.Sys.HostEntry hostEntry, bool justAddresses, out string? hostName, out string[] aliases, out IPAddress[] addresses) 63IPAddress[] localAddresses; 66localAddresses = Array.Empty<IPAddress>(); 95localAddresses = new IPAddress[nativeAddressCount]; 130public static unsafe SocketError TryGetAddrInfo(string name, bool justAddresses, AddressFamily addressFamily, out string? hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode) 145addresses = Array.Empty<IPAddress>(); 154public static unsafe string? TryGetNameInfo(IPAddress addr, out SocketError socketError, out int nativeErrorCode)

System\Net\NameResolutionTelemetry.cs (5)

134IPAddress a => a.ToString(), 135KeyValuePair<IPAddress, AddressFamily> t => t.Key.ToString(), 176_activity.DisplayName = hostNameOrAddress is IPAddress ? $"DNS reverse lookup {host}" : $"DNS lookup {host}"; 198IPAddress[] addresses => GetStringValues(addresses), 231static string[] GetStringValues(IPAddress[] addresses)

System\Net\NetworkInformation\GatewayIPAddressInformation.cs (1)

14public abstract IPAddress Address { get; }

System\Net\NetworkInformation\InternalIPAddressCollection.cs (9)

10private readonly List<IPAddress> _addresses; 14_addresses = new List<IPAddress>(); 17internal InternalIPAddressCollection(List<IPAddress> addresses) 22public override void CopyTo(IPAddress[] array, int offset) 43public override void Add(IPAddress address) 48internal void InternalAdd(IPAddress address) 53public override bool Contains(IPAddress address) 58public override IPAddress this[int index] 66public override IEnumerator<IPAddress> GetEnumerator()

System\Net\NetworkInformation\IPAddressInformation.cs (1)

16public abstract IPAddress Address { get; }

System\Net\NetworkInformation\IPAddressUtil.cs (3)

15public static bool IsMulticast(IPAddress address) 35public static unsafe IPAddress GetIPAddressFromNativeInfo(Interop.Sys.IpAddressInfo* addressInfo) 37IPAddress ipAddress = new IPAddress(new ReadOnlySpan<byte>(addressInfo->AddressBytes, addressInfo->NumAddressBytes));

System\Net\NetworkInformation\LinuxIPAddressInformation.cs (3)

10private readonly IPAddress _address; 12public LinuxIPAddressInformation(IPAddress address) 17public override IPAddress Address { get { return _address; } }

System\Net\NetworkInformation\LinuxIPInterfaceProperties.cs (3)

75List<IPAddress> internalCollection = new List<IPAddress>(); 86List<IPAddress> internalCollection

System\Net\NetworkInformation\LinuxNetworkInterface.cs (1)

116var address = new IPAddress(new ReadOnlySpan<byte>(ai->AddressBytes, ai->NumAddressBytes));

System\Net\NetworkInformation\SimpleGatewayIPAddressInformation.Unix.cs (3)

8private readonly IPAddress _address; 10public SimpleGatewayIPAddressInformation(IPAddress address) 15public override IPAddress Address

System\Net\NetworkInformation\StringParsingHelpers.Addresses.cs (10)

29IPAddress address = new IPAddress(addressValue); 68IPAddress address = ParseIPv6HexString(token[4], isNetworkOrder: true); 80internal static void ParseDhcpServerAddressesFromLeasesFile(List<IPAddress> collection, string filePath, string name) 111if (IPAddress.TryParse(dhcpAddressSpan, out IPAddress? dhcpAddress)) 124internal static List<IPAddress> ParseWinsServerAddressesFromSmbConfFile(string smbConfFilePath) 126List<IPAddress> collection = new List<IPAddress>(); 161IPAddress address = IPAddress.Parse(addressSpan);

System\Net\NetworkInformation\StringParsingHelpers.Connections.cs (7)

281IPAddress localIPAddress = ParseHexIPAddress(localAddressAndPort.AsSpan(0, indexOfColon)); 301IPAddress ipAddress = ParseHexIPAddress(colonSeparatedAddress.AsSpan(0, indexOfColon)); 319internal static IPAddress ParseHexIPAddress(ReadOnlySpan<char> remoteAddressString) 337private static IPAddress ParseIPv4HexString(ReadOnlySpan<char> hexAddress) 339IPAddress ipAddress; 358private static IPAddress ParseIPv6HexString(ReadOnlySpan<char> hexAddress, bool isNetworkOrder = false) 384IPAddress ipAddress = new IPAddress(addressBytes);

System\Net\NetworkInformation\StringParsingHelpers.Dns.cs (5)

18internal static List<IPAddress> ParseDnsAddressesFromResolvConfFile(string data) 26List<IPAddress> addresses = new List<IPAddress>(); 30if (IPAddress.TryParse(addressString, out IPAddress? parsedAddress))

System\Net\NetworkInformation\UnicastIPAddressInformation.cs (2)

51public abstract IPAddress IPv4Mask { get; } 70internal static IPAddress PrefixLengthToSubnetMask(byte prefixLength, AddressFamily family)

System\Net\NetworkInformation\UnixIPGlobalProperties.cs (2)

76IPAddress ipAddress = IPAddressUtil.GetIPAddressFromNativeInfo(ipAddr); 94IPAddress ipAddress = IPAddressUtil.GetIPAddressFromNativeInfo(ipAddr);

System\Net\NetworkInformation\UnixIPInterfaceProperties.cs (2)

78foreach (IPAddress address in uni.MulticastAddresess) 103List<IPAddress> internalAddresses = StringParsingHelpers.ParseDnsAddressesFromResolvConfFile(File.ReadAllText(NetworkFiles.EtcResolvConfFile));

System\Net\NetworkInformation\UnixMulticastIPAddressInformation.cs (3)

10private readonly IPAddress _address; 12public UnixMulticastIPAddressInformation(IPAddress address) 17public override IPAddress Address { get { return _address; } }

System\Net\NetworkInformation\UnixNetworkInterface.cs (6)

16internal List<IPAddress>? _multicastAddresses; 65public List<IPAddress>? MulticastAddresess { get { return _multicastAddresses; } } 68protected void AddAddress(IPAddress ipAddress, int prefix) 73_multicastAddresses ??= new List<IPAddress>(); 85IPAddress ipAddress = IPAddressUtil.GetIPAddressFromNativeInfo(addressInfo); 92IPAddress address = IPAddressUtil.GetIPAddressFromNativeInfo(addressInfo);

System\Net\NetworkInformation\UnixUnicastIPAddressInformation.cs (5)

12private readonly IPAddress _address; 15public UnixUnicastIPAddressInformation(IPAddress address, int prefixLength) 21public override IPAddress Address { get { return _address; } } 103public override IPAddress IPv4Mask 111return IPAddress.Any;

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

11public static IPAddress GetIPAddress(ReadOnlySpan<byte> socketAddressBuffer) 32public static void SetIPAddress(Span<byte> socketAddressBuffer, IPAddress address)

System\Net\NetworkInformation\Ping.cs (42)

System\Net\NetworkInformation\Ping.PingUtility.cs (6)

18private Process GetPingProcess(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 51private PingReply SendWithPingUtility(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 74private async Task<PingReply> SendWithPingUtilityAsync(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 108private static PingReply ParsePingUtilityOutput(IPAddress address, int exitCode, string stdout) 141IPAddress? address; 142if (addressStart < 5 || addressLength <= 0 || !IPAddress.TryParse(stdout.AsSpan(addressStart, addressLength), out address))

System\Net\NetworkInformation\Ping.RawSocket.cs (8)

22private static readonly ushort DontFragment = OperatingSystem.IsFreeBSD() ? (ushort)IPAddress.HostToNetworkOrder((short)0x4000) : (ushort)0x4000; 24private static unsafe SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 40iph.TotalLength = OperatingSystem.IsFreeBSD() ? (ushort)IPAddress.HostToNetworkOrder((short)totalLength) : (ushort)totalLength; 245IPAddress address = ((IPEndPoint)socketConfig.EndPoint).Address; 250private static unsafe PingReply SendIcmpEchoRequestOverRawSocket(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 300private static PingReply CreatePingReplyForUnreachableHost(IPAddress address, Socket socket) 322private async Task<PingReply> SendIcmpEchoRequestOverRawSocketAsync(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 387private static PingReply CreatePingReply(IPStatus status, IPAddress? address = null, long rtt = 0)

System\Net\NetworkInformation\Ping.Unix.cs (2)

22private PingReply SendPingCore(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 30private Task<PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions? options)

System\Net\NetworkInformation\PingReply.cs (2)

9IPAddress address, 24public IPAddress Address { get; }

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

11public static IPAddress GetIPAddress(ReadOnlySpan<byte> socketAddressBuffer) 32public static void SetIPAddress(Span<byte> socketAddressBuffer, IPAddress address)

src\libraries\Common\src\System\Net\SocketAddress.cs (2)

95internal SocketAddress(IPAddress ipAddress) 122internal SocketAddress(IPAddress ipaddress, int port)

src\libraries\Common\src\System\Net\SocketAddressExtensions.cs (1)

11public static IPAddress GetIPAddress(this SocketAddress socketAddress) => IPEndPointExtensions.GetIPAddress(socketAddress.Buffer.Span);

System\Net\IPAddress.cs (37)

22public class IPAddress : ISpanFormattable, ISpanParsable<IPAddress>, IUtf8SpanFormattable, IUtf8SpanParsable<IPAddress> 24public static readonly IPAddress Any = new ReadOnlyIPAddress([0, 0, 0, 0]); 25public static readonly IPAddress Loopback = new ReadOnlyIPAddress([127, 0, 0, 1]); 26public static readonly IPAddress Broadcast = new ReadOnlyIPAddress([255, 255, 255, 255]); 27public static readonly IPAddress None = Broadcast; 31public static readonly IPAddress IPv6Any = new IPAddress((ReadOnlySpan<byte>)[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 0); 32public static readonly IPAddress IPv6Loopback = new IPAddress((ReadOnlySpan<byte>)[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 0); 33public static readonly IPAddress IPv6None = IPv6Any; 35private static readonly IPAddress s_loopbackMappedToIPv6 = new IPAddress((ReadOnlySpan<byte>)[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 127, 0, 0, 1], 0); 121/// Initializes a new instance of the <see cref='System.Net.IPAddress'/> 229/// <summary>Determines whether the provided span contains a valid <see cref="IPAddress"/>.</summary> 233/// <summary>Determines whether the provided span contains a valid <see cref="IPAddress"/>.</summary> 239/// Converts an IP address string to an <see cref='System.Net.IPAddress'/> instance. 242public static bool TryParse([NotNullWhen(true)] string? ipString, [NotNullWhen(true)] out IPAddress? address) 260public static bool TryParse(ReadOnlySpan<byte> utf8Text, [NotNullWhen(true)] out IPAddress? result) 266public static bool TryParse(ReadOnlySpan<char> ipSpan, [NotNullWhen(true)] out IPAddress? address) 273static bool IUtf8SpanParsable<IPAddress>.TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 277static bool IParsable<IPAddress>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 282static bool ISpanParsable<IPAddress>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 286public static IPAddress Parse(string ipString) 298public static IPAddress Parse(ReadOnlySpan<byte> utf8Text) 303public static IPAddress Parse(ReadOnlySpan<char> ipSpan) 309static IPAddress IUtf8SpanParsable<IPAddress>.Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider) => 314static IPAddress ISpanParsable<IPAddress>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) => 319static IPAddress IParsable<IPAddress>.Parse(string s, IFormatProvider? provider) => 562public static bool IsLoopback(IPAddress address) 679return comparand is IPAddress address && Equals(address); 682internal bool Equals(IPAddress comparand) 736public IPAddress MapToIPv6() 754public IPAddress MapToIPv4()

System\Net\IPAddressParser.cs (4)

37internal static IPAddress? Parse<TChar>(ReadOnlySpan<TChar> ipSpan, bool tryParse) 81address = (uint)IPAddress.HostToNetworkOrder(unchecked((int)tmpAddr)); 152address = (uint)IPAddress.NetworkToHostOrder(unchecked((int)address)); 306return (uint)IPAddress.HostToNetworkOrder(unchecked((int)ipv4address));

System\Net\IPEndPoint.cs (5)

25private IPAddress _address; 47public IPEndPoint(IPAddress address, int port) 63public IPAddress Address 114if (IPAddress.TryParse(s.Slice(0, addressLength), out IPAddress? address))

System\Net\IPNetwork.cs (19)

17/// Represents an IP network with an <see cref="IPAddress"/> containing the network prefix and an <see cref="int"/> defining the prefix length. 26private readonly IPAddress? _baseAddress; 29/// Gets the <see cref="IPAddress"/> that represents the prefix of the network. 31public IPAddress BaseAddress => _baseAddress ?? IPAddress.Any; 39/// Initializes a new instance of the <see cref="IPNetwork"/> class with the specified <see cref="IPAddress"/> and prefix length. 41/// <param name="baseAddress">The <see cref="IPAddress"/> that represents the prefix of the network.</param> 46public IPNetwork(IPAddress baseAddress, int prefixLength) 71private IPNetwork(IPAddress baseAddress, int prefixLength, bool _) 78/// Determines whether a given <see cref="IPAddress"/> is part of the network. 80/// <param name="address">The <see cref="IPAddress"/> to check.</param> 81/// <returns><see langword="true"/> if the <see cref="IPAddress"/> is part of the network; otherwise, <see langword="false"/>.</returns> 83public bool Contains(IPAddress address) 204if (IPAddress.TryParse(ipAddressSpan, out IPAddress? address) && 233if (IPAddress.TryParse(ipAddressSpan, out IPAddress? address) && 248private static int GetMaxPrefixLength(IPAddress baseAddress) => baseAddress.AddressFamily == AddressFamily.InterNetwork ? 32 : 128; 250private static bool HasNonZeroBitsAfterNetworkPrefix(IPAddress baseAddress, int prefixLength)

System\Net\NetworkInformation\IPAddressCollection.cs (7)

8public class IPAddressCollection : ICollection<IPAddress> 14public virtual void CopyTo(IPAddress[] array, int offset) 35public virtual void Add(IPAddress address) 40public virtual bool Contains(IPAddress address) 50public virtual IEnumerator<IPAddress> GetEnumerator() 55public virtual IPAddress this[int index] 63public virtual bool Remove(IPAddress address)

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

11public static IPAddress GetIPAddress(ReadOnlySpan<byte> socketAddressBuffer) 32public static void SetIPAddress(Span<byte> socketAddressBuffer, IPAddress address)

src\libraries\Common\src\System\Net\Security\CertificateValidation.Unix.cs (2)

39IPAddress? hostnameAsIp; 40if (IPAddress.TryParse(hostName, out hostnameAsIp))

System\Net\Quic\Internal\MsQuicHelpers.cs (2)

15internal static bool TryParse(this EndPoint endPoint, out string? host, out IPAddress? address, out int port) 19host = IPAddress.TryParse(dnsEndPoint.Host, out address) ? null : dnsEndPoint.Host;

System\Net\Quic\QuicConnection.cs (4)

383if (!options.RemoteEndPoint.TryParse(out string? host, out IPAddress? address, out int port)) 396IPAddress[] addresses = await Dns.GetHostAddressesAsync(host, cancellationToken).ConfigureAwait(false); 426string sni = (IPAddress.IsValid(options.ClientAuthenticationOptions.TargetHost) ? null : options.ClientAuthenticationOptions.TargetHost) ?? host ?? string.Empty; 461if (IPAddress.IsValid(targetHost))

System\Net\Quic\QuicListener.cs (1)

148if (options.ListenEndPoint.Address.Equals(IPAddress.IPv6Any))

System\Net\FtpControlStream.cs (2)

810private static string FormatAddress(IPAddress address, int Port) 833private static string FormatAddressV6(IPAddress address, int port)

System\Net\HttpWebRequest.cs (3)

1764IPAddress[] addresses = parameters.Async ? 1783static void BindHelper(ServicePoint servicePoint, ref IPAddress[] addresses, Socket socket, int port) 1791foreach (IPAddress address in addresses)

System\Net\NetworkStreamWrapper.cs (1)

31internal IPAddress ServerAddress

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (2)

360IPAddress.IsValid(sslAuthenticationOptions.TargetHost) || 418if (!string.IsNullOrEmpty(sslAuthenticationOptions.TargetHost) && !IPAddress.IsValid(sslAuthenticationOptions.TargetHost))

src\libraries\Common\src\System\Net\Security\CertificateValidation.Unix.cs (2)

39IPAddress? hostnameAsIp; 40if (IPAddress.TryParse(hostName, out hostnameAsIp))

src\libraries\Common\src\System\Net\InteropIPAddressExtensions.Unix.cs (2)

11public static unsafe Interop.Sys.IPAddress GetNativeIPAddress(this IPAddress ipAddress) 27public static unsafe IPAddress GetIPAddress(this Interop.Sys.IPAddress nativeIPAddress)

src\libraries\Common\src\System\Net\IPEndPointExtensions.cs (2)

11public static IPAddress GetIPAddress(ReadOnlySpan<byte> socketAddressBuffer) 32public static void SetIPAddress(Span<byte> socketAddressBuffer, IPAddress address)

src\libraries\Common\src\System\Net\IPEndPointStatics.cs (2)

9internal static readonly IPEndPoint Any = new IPEndPoint(IPAddress.Any, AnyPort); 10internal static readonly IPEndPoint IPv6Any = new IPEndPoint(IPAddress.IPv6Any, AnyPort);

src\libraries\Common\src\System\Net\SocketAddressExtensions.cs (1)

11public static IPAddress GetIPAddress(this SocketAddress socketAddress) => IPEndPointExtensions.GetIPAddress(socketAddress.Buffer.Span);

System\Net\Sockets\IPPacketInformation.cs (3)

10private readonly IPAddress _address; 13internal IPPacketInformation(IPAddress address, int networkInterface) 19public IPAddress Address => _address;

System\Net\Sockets\MulticastOption.cs (13)

9private IPAddress _group; 10private IPAddress? _localAddress; 15public MulticastOption(IPAddress group, IPAddress mcint) 24public MulticastOption(IPAddress group, int interfaceIndex) 36public MulticastOption(IPAddress group) 42LocalAddress = IPAddress.Any; 46public IPAddress Group 57public IPAddress? LocalAddress 84private IPAddress _group; 89public IPv6MulticastOption(IPAddress group, long ifindex) 102public IPv6MulticastOption(IPAddress group) 111public IPAddress Group

System\Net\Sockets\Socket.cs (16)

25private static readonly IPAddress s_IPAddressAnyMapToIPv6 = IPAddress.Any.MapToIPv6(); 876public void Connect(IPAddress address, int port) 920IPAddress? parsedAddress; 921if (IPAddress.TryParse(host, out parsedAddress)) 927IPAddress[] addresses = Dns.GetHostAddresses(host); 932public void Connect(IPAddress[] addresses, int port) 957foreach (IPAddress address in addresses) 2456public IAsyncResult BeginConnect(IPAddress address, int port, AsyncCallback? requestCallback, object? state) => 2459public IAsyncResult BeginConnect(IPAddress[] addresses, int port, AsyncCallback? requestCallback, object? state) => 3336IPAddress addr = ip.Address; 3570IPAddress? boundAddress = ipEndPoint?.Address; 3577if ((boundAddress != null && IsDualMode && (boundAddress.IsIPv4MappedToIPv6 || boundAddress.Equals(IPAddress.IPv6Any)))) 3874IPAddress address = ipEndpoint.Address; 3875return IPAddress.Any.Equals(address) || IPAddress.IPv6Any.Equals(address) || s_IPAddressAnyMapToIPv6.Equals(address);

System\Net\Sockets\Socket.Tasks.cs (8)

135public Task ConnectAsync(IPAddress address, int port) => ConnectAsync(new IPEndPoint(address, port)); 144public ValueTask ConnectAsync(IPAddress address, int port, CancellationToken cancellationToken) => ConnectAsync(new IPEndPoint(address, port), cancellationToken); 152public Task ConnectAsync(IPAddress[] addresses, int port) => ConnectAsync(addresses, port, CancellationToken.None).AsTask(); 161public ValueTask ConnectAsync(IPAddress[] addresses, int port, CancellationToken cancellationToken) 191async ValueTask Core(IPAddress[] addresses, int port, CancellationToken cancellationToken) 195foreach (IPAddress address in addresses) 242EndPoint ep = IPAddress.TryParse(host, out IPAddress? parsedAddress) ? (EndPoint)

System\Net\Sockets\SocketAsyncEventArgs.cs (3)

690Task<IPAddress[]> addressesTask = Dns.GetHostAddressesAsync(endPoint.Host, endPoint.AddressFamily, cancellationToken); 709async Task Core(MultiConnectSocketAsyncEventArgs internalArgs, Task<IPAddress[]> addressesTask, int port, SocketType socketType, ProtocolType protocolType, CancellationToken cancellationToken) 718foreach (IPAddress address in await addressesTask.ConfigureAwait(false))

System\Net\Sockets\SocketPal.Unix.cs (5)

1456int interfaceIndex = IPAddress.NetworkToHostOrder(optionValue); 1540IPAddress localAddress = optionValue.LocalAddress ?? IPAddress.Any; 1719var multicastAddress = new IPAddress((long)opt.MulticastAddress); 1720var localAddress = new IPAddress((long)opt.LocalAddress);

System\Net\Sockets\SocketTaskExtensions.cs (4)

28public static Task ConnectAsync(this Socket socket, IPAddress address, int port) => 31public static ValueTask ConnectAsync(this Socket socket, IPAddress address, int port, CancellationToken cancellationToken) => 34public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port) => 37public static ValueTask ConnectAsync(this Socket socket, IPAddress[] addresses, int port, CancellationToken cancellationToken) =>

System\Net\Sockets\TCPClient.cs (8)

143public void Connect(IPAddress address, int port) 173public void Connect(IPAddress[] ipAddresses, int port) 184public Task ConnectAsync(IPAddress address, int port) => 190public Task ConnectAsync(IPAddress[] addresses, int port) => 207public ValueTask ConnectAsync(IPAddress address, int port, CancellationToken cancellationToken) => 213public ValueTask ConnectAsync(IPAddress[] addresses, int port, CancellationToken cancellationToken) => 231public IAsyncResult BeginConnect(IPAddress address, int port, AsyncCallback? requestCallback, object? state) => 237public IAsyncResult BeginConnect(IPAddress[] addresses, int port, AsyncCallback? requestCallback, object? state) =>

System\Net\Sockets\TCPListener.cs (4)

34public TcpListener(IPAddress localaddr, int port) 57_serverSocketEP = new IPEndPoint(IPAddress.Any, port); 258listener = new TcpListener(IPAddress.IPv6Any, port); 264listener = new TcpListener(IPAddress.Any, port);

System\Net\Sockets\UDPClient.cs (16)

69localEP = new IPEndPoint(IPAddress.Any, port); 73localEP = new IPEndPoint(IPAddress.IPv6Any, port); 250private void CheckForBroadcast(IPAddress ipAddress) 266private static bool IsBroadcast(IPAddress address) 275return address.Equals(IPAddress.Broadcast); 340IPAddress[] addresses = Dns.GetHostAddresses(hostname); 394public void JoinMulticastGroup(IPAddress multicastAddr) 421public void JoinMulticastGroup(IPAddress multicastAddr, IPAddress localAddress) 437public void JoinMulticastGroup(int ifindex, IPAddress multicastAddr) 457public void JoinMulticastGroup(IPAddress multicastAddr, int timeToLive) 478public void DropMulticastGroup(IPAddress multicastAddr) 506public void DropMulticastGroup(IPAddress multicastAddr, int ifindex) 702IPAddress[] addresses = Dns.GetHostAddresses(hostname); 723foreach (IPAddress address in addresses) 801public void Connect(IPAddress addr, int port)

System\Net\WebProxy.NonWasm.cs (4)

13private static volatile IPAddress[]? s_localAddresses; 25if (IPAddress.TryParse(hostString, out IPAddress? hostAddress)) 28IPAddress[] localAddresses = s_localAddresses ??= Dns.GetHostEntry(Dns.GetHostName()).AddressList;

System\Security\Cryptography\X509Certificates\SubjectAlternativeNameBuilder.cs (1)

43public void AddIpAddress(IPAddress ipAddress)

System\Security\Cryptography\X509Certificates\X509Certificate2.cs (6)

1203/// If the hostname parses as an <see cref="IPAddress"/> then IPAddress matching is done; 1262/// <seealso cref="IPAddress.TryParse(string, out IPAddress)"/> 1267IPAddress? ipAddress; 1269if (!IPAddress.TryParse(hostname, out ipAddress)) 1309foreach (IPAddress sanEntry in san.EnumerateIPAddresses())

System\Security\Cryptography\X509Certificates\X509SubjectAlternativeNameExtension.cs (2)

57public IEnumerable<IPAddress> EnumerateIPAddresses() 64private static IEnumerable<IPAddress> EnumerateIPAddresses(List<GeneralNameAsn> decoded)

Startup.cs (2)

54options.Listen(IPAddress.Loopback, basePort, listenOptions => 62options.Listen(IPAddress.Loopback, basePort + 1, listenOptions =>

MS\Internal\AutomationProxies\WindowsIPAddress.cs (2)

122IPAddress ipAddress = GetIPAddressFromString (val); 221private IPAddress GetIPAddressFromString (String strIPAddress)

FakeAddress.cs (3)

10public static string HttpAddress = "http://" + IPAddress.None + ":0"; 12public static string HttpsAddress = "https://" + IPAddress.None + ":0"; 14public static string TcpAddress = "net.tcp://" + IPAddress.None + ":0";

Program.cs (2)

25options.Listen(IPAddress.Any, 5001, listenOptions => 31options.Listen(IPAddress.Any, 5002, listenOptions =>

Program.cs (1)

15options.Listen(IPAddress.Any, 5007, listenOptions =>

Program.cs (1)

20options.Listen(IPAddress.Loopback, 44307, listenOptions =>