IPAddress

System\Net\IPAddress.cs (1)

777private sealed class ReadOnlyIPAddress : IPAddress

AzurePostgresExtensions.cs (4)

396StartIPAddress = new IPAddress([0, 0, 0, 0]), 397EndIPAddress = new IPAddress([0, 0, 0, 0]) 407StartIPAddress = new IPAddress([0, 0, 0, 0]), 408EndIPAddress = new IPAddress([255, 255, 255, 255])

TestTransport\InMemoryHttpClientSlim.cs (1)

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

HttpClientSlim.cs (1)

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

KestrelServerTests.cs (2)

1002resolvedEndPoint = new IPEndPoint(new IPAddress(ipEndPoint.Address.GetAddressBytes()), port); 1054resolvedEndPoint = new IPEndPoint(new IPAddress(ipEndPoint.Address.GetAddressBytes()), port);

Resolver\DnsResolver.cs (2)

100addresses.Add(new AddressResult(response.CreatedAt.AddSeconds(additional.Ttl), new IPAddress(additional.Data.Span))); 339target = new IPAddress(record.Data.Span);

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)

117var 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)

751return new IPAddress(labels, 0); 765return 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);

System\Net\IPNetwork.cs (2)

251: new IPAddress(newAddress); 275: new IPAddress(MemoryMarshal.AsBytes(new Span<UInt128>(ref newAddress)));

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)

101yield return new IPAddress(value);

HttpSys\HttpSysConfigurator.cs (1)

19var ipPort = new IPEndPoint(new IPAddress([0, 0, 0, 0]), 6000);

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

235return new IPAddress ((long) ipV4);

DashboardWebApplication.cs (2)

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

Integration\DashboardClientAuthTests.cs (1)

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

Integration\MockOpenIdAuthority.cs (1)

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

Integration\StartupTests.cs (2)

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

Dashboard\DashboardServiceHost.cs (1)

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

Dcp\DcpExecutor.cs (4)

1688var s when IPAddress.TryParse(s, out var ipAddress) => ipAddress switch // The host is an IP address 1690var ip when IPAddress.Any.Equals(ip) => ("localhost", EndpointBindingMode.IPv4AnyAddresses), // 0.0.0.0 (IPv4 all addresses) 1691var ip when IPAddress.IPv6Any.Equals(ip) => ("localhost", EndpointBindingMode.IPv6AnyAddresses), // :: (IPv6 all addresses)

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)

164socket.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)

164socket.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))

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)

1053o.Listen(IPAddress.Parse("127.0.0.1"), port, listenOptions => 1374o.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 1846kestrel.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 2015kestrel.Listen(IPAddress.Parse("127.0.0.1"), 0, listenOptions => 2093IPAddress remoteAddress = null; 2095IPAddress localAddress = null; 2178kestrel.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)

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

Infrastructure\TestHelpers.cs (1)

27httpContext.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)

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

ForwardedHeadersOptions.cs (6)

6using IPAddress = System.Net.IPAddress; 83public IList<IPAddress> KnownProxies { get; } = new List<IPAddress>() { IPAddress.IPv6Loopback }; 90public IList<AspNetIPNetwork> KnownNetworks { get; } = new List<AspNetIPNetwork>() { new(IPAddress.Loopback, 8) }; 95public IList<IPNetwork> KnownIPNetworks { get; } = new List<IPNetwork>() { new(IPAddress.Loopback, 8) };

IPNetwork.cs (17)

18/// Create a new <see cref="IPNetwork"/> with the specified <see cref="IPAddress"/> and prefix length. 20/// <param name="prefix">The <see cref="IPAddress"/>.</param> 23public IPNetwork(IPAddress prefix, int prefixLength) : this(prefix, prefixLength, true) 27private IPNetwork(IPAddress prefix, int prefixLength, bool checkPrefixLengthRange) 42/// Get the <see cref="IPAddress"/> that represents the prefix for the network. 44public IPAddress Prefix { get; } 56/// Determine whether a given The <see cref="IPAddress"/> is part of the IP network. 58/// <param name="address">The <see cref="IPAddress"/>.</param> 59/// <returns><see langword="true"/> if the <see cref="IPAddress"/> is part of the IP network. Otherwise, <see langword="false"/>.</returns> 60public bool Contains(IPAddress address) 98private static bool IsValidPrefixLengthRange(IPAddress prefix, int prefixLength) 123/// <inheritdoc cref="TryParseComponents(ReadOnlySpan{char}, out IPAddress?, out int)"/> 126if (!TryParseComponents(networkSpan, out var prefix, out var prefixLength)) 154/// <inheritdoc cref="TryParseComponents(ReadOnlySpan{char}, out IPAddress?, out int)"/> 159if (!TryParseComponents(networkSpan, out var prefix, out var prefixLength)) 184[NotNullWhen(true)] out IPAddress? prefix, 196if (!IPAddress.TryParse(networkSpan.Slice(0, forwardSlashIndex), out prefix))

ForwardedHeadersMiddlewareTest.cs (15)

77c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 138c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 176c.Connection.RemoteIpAddress = IPAddress.Parse(originalIp); 185Assert.Equal(new IPEndPoint(IPAddress.Parse(originalIp), 99).ToString(), 234foreach (var ip in knownIPs.Split(',').Select(text => IPAddress.Parse(text))) 249c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 885c.Connection.RemoteIpAddress = IPAddress.Parse(remoteIp); 995var proxy = IPAddress.Parse("10.0.0.1"); 1012c.Connection.RemoteIpAddress = IPAddress.Parse("10.0.0.1"); 1093var proxy = IPAddress.Parse(knownProxy); 1099var networkIp = IPAddress.Parse(knownNetworkParts[0]);

IPNetworkTest.cs (8)

26var network = new IPNetwork(IPAddress.Parse(prefixText), length); 27Assert.True(network.Contains(IPAddress.Parse(addressText))); 40var network = new IPNetwork(IPAddress.Parse(prefixText), length); 41Assert.False(network.Contains(IPAddress.Parse(addressText))); 52var address = IPAddress.Parse(prefixText); 70var 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)

437{ OwinConstants.CommonKeys.LocalIpAddress, new FeatureMap<IHttpConnectionFeature>(feature => feature.LocalIpAddress.ToString(), (feature, value) => feature.LocalIpAddress = IPAddress.Parse(Convert.ToString(value, CultureInfo.InvariantCulture))) }, 438{ OwinConstants.CommonKeys.RemoteIpAddress, new FeatureMap<IHttpConnectionFeature>(feature => feature.RemoteIpAddress.ToString(), (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)

318public IPAddress? RemoteIpAddress => RemoteEndPoint.GetIPAddress(); 320public IPAddress? LocalIpAddress => LocalEndPoint.GetIPAddress();

RequestProcessing\RequestContext.FeatureCollection.cs (4)

54private IPAddress? _remoteIpAddress; 55private IPAddress? _localIpAddress; 237IPAddress? IHttpConnectionFeature.LocalIpAddress 255IPAddress? IHttpConnectionFeature.RemoteIpAddress

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

14internal abstract IPAddress? GetIPAddress(); 43return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin_port); 46internal override IPAddress? GetIPAddress() 67return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin6_port); 70internal override IPAddress? GetIPAddress()

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))

NativeInterop\SocketAddressTests.cs (2)

28sin6_port = (ushort)IPAddress.HostToNetworkOrder((short)expectedPort) 52sin_port = (ushort)IPAddress.HostToNetworkOrder((short)expectedPort)

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 (5)

14internal abstract IPAddress? GetIPAddress(); 43return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin_port); 46internal override IPAddress? GetIPAddress() 67return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin6_port); 70internal override IPAddress? GetIPAddress()

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)

141public IPAddress? RemoteIpAddress { get; set; } 143public IPAddress? LocalIpAddress { get; set; }

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

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

KestrelConfigurationLoader.cs (2)

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

KestrelServerOptions.cs (2)

476public void Listen(IPAddress address, int port) 485public void Listen(IPAddress address, int port, Action<ListenOptions> configure)

ListenOptions.cs (1)

234protected internal ListenOptions Clone(IPAddress address)

LocalhostListenOptions.cs (3)

21: base(new IPEndPoint(IPAddress.Loopback, port)) 44var v4Options = Clone(IPAddress.Loopback); 58var v6Options = Clone(IPAddress.IPv6Loopback);

AddressBinderTests.cs (7)

31Assert.Equal(IPAddress.Parse(expectedAddress), endpoint.Address); 60Assert.Equal(IPAddress.IPv6Any, listenOptions.IPEndPoint.Address); 71Assert.Equal(IPAddress.Loopback, listenOptions.IPEndPoint.Address); 89Assert.Equal(IPAddress.Loopback, listenOptions.IPEndPoint.Address); 174Assert.Equal(IPAddress.Parse(ip), listenOptions.IPEndPoint.Address); 291if (endpoint.IPEndPoint.Address.Equals(IPAddress.IPv6Any)) 297if (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 (5)

14internal abstract IPAddress? GetIPAddress(); 43return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin_port); 46internal override IPAddress? GetIPAddress() 67return (ushort)IPAddress.NetworkToHostOrder((short)_sockaddr.sin6_port); 70internal override IPAddress? GetIPAddress()

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)

268Assert.Equal(IPAddress.Parse("1.1.1.1"), features.Get<IHttpConnectionFeature>().RemoteIpAddress); 271context.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)

39var res = BitConverter.TryWriteBytes(timestepAsBytes, 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))

Resolver\DnsResolver.cs (7)

123res[index] = new AddressResult(DateTime.MaxValue, IPAddress.IPv6Loopback); 128res[index] = new AddressResult(DateTime.MaxValue, IPAddress.Loopback); 161return ValueTask.FromResult<AddressResult[]>([new AddressResult(DateTime.MaxValue, IPAddress.Loopback)]); 165return ValueTask.FromResult<AddressResult[]>([new AddressResult(DateTime.MaxValue, IPAddress.IPv6Loopback)]); 214if (!TryReadAddress(answer, queryType, out IPAddress? address)) 262if (!TryReadAddress(answer, queryType, out IPAddress? address)) 328static bool TryReadAddress(in DnsResourceRecord record, QueryType type, [NotNullWhen(true)] out IPAddress? target)

Resolver\NetworkInfo.cs (1)

23foreach (IPAddress server in properties.DnsAddresses)

Resolver\ResolvConf.cs (2)

28if (tokens.Length >= 2 && IPAddress.TryParse(tokens[1], out IPAddress? address))

Resolver\ResultTypes.cs (1)

8internal record struct AddressResult(DateTime ExpiresAt, IPAddress Address);

DnsSrvServiceEndpointResolverTests.cs (8)

44new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 66, 8888, "srv-a", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.Parse("10.10.10.10"))]), 45new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 62, 9999, "srv-b", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.IPv6Loopback)]), 70Assert.Equal(new IPEndPoint(IPAddress.Parse("10.10.10.10"), 8888), eps[0].EndPoint); 71Assert.Equal(new IPEndPoint(IPAddress.IPv6Loopback, 9999), eps[1].EndPoint); 95new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 66, 8888, "srv-a", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.Parse("10.10.10.10"))]), 96new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 62, 9999, "srv-b", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.IPv6Loopback)]), 151Assert.Equal(new IPEndPoint(IPAddress.Parse("10.10.10.10"), 8888), eps[0].EndPoint); 152Assert.Equal(new IPEndPoint(IPAddress.IPv6Loopback, 9999), eps[1].EndPoint);

Resolver\LoopbackDnsServer.cs (4)

23_dnsSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); 57EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); 80_tcpSocket.Bind(new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)_dnsSocket.LocalEndPoint!).Port)); 234public static List<DnsResourceRecord> AddAddress(this List<DnsResourceRecord> records, string name, int ttl, IPAddress address)

Resolver\ResolvConfTests.cs (1)

24Assert.Equal(new IPEndPoint(IPAddress.Parse("10.96.0.10"), 53), ipAddress);

Resolver\ResolveAddressesTests.cs (19)

Resolver\ResolveServiceTests.cs (2)

18IPAddress address = IPAddress.Parse("172.213.245.111");

Resolver\RetryTests.cs (10)

44IPAddress address = IPAddress.Parse("172.213.245.111"); 83IPAddress address = IPAddress.Parse("172.213.245.111"); 139IPAddress address = IPAddress.Parse("172.213.245.111"); 197IPAddress address = IPAddress.Parse("172.213.245.111"); 237IPAddress address = IPAddress.Parse("172.213.245.111");

Resolver\TcpFailoverTests.cs (6)

20IPAddress address = IPAddress.Parse("172.213.245.111"); 87IPAddress address = IPAddress.Parse("172.213.245.111"); 114IPAddress address = IPAddress.Parse("172.213.245.111");

Fuzzers\DnsResponseFuzzer.cs (1)

22_resolver = new DnsResolver(new ResolverOptions(new IPEndPoint(IPAddress.Loopback, 53))

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 (3)

277new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 66, 8888, "srv-a", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.Parse("10.10.10.10"))]), 278new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 62, 9999, "srv-b", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.IPv6Loopback)]), 279new ServiceResult(DateTime.UtcNow.AddSeconds(60), 99, 62, 7777, "srv-c", [new AddressResult(DateTime.UtcNow.AddSeconds(64), IPAddress.Loopback)])

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)

35: this(app, context, new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))) 47var 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)

35: this(app, context, new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0))) 47var 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)

311options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions => 385socket.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())); 632socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort())); 679socket.Connect(new IPEndPoint(IPAddress.Loopback, host.GetPort())); 773socket.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 (68)

40public static IPHostEntry GetHostEntry(IPAddress address) 46if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) 75if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostNameOrAddress, out IPAddress? address)) 77if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) 152public static Task<IPHostEntry> GetHostEntryAsync(IPAddress address) 158if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) 167IPHostEntry ipHostEntry = GetHostEntryCore((IPAddress)s, AddressFamily.Unspecified, activity); 168if (NetEventSource.Log.IsEnabled()) NetEventSource.Info((IPAddress)s, $"{ipHostEntry} with {ipHostEntry.AddressList.Length} entries"); 173public static IAsyncResult BeginGetHostEntry(IPAddress address, AsyncCallback? requestCallback, object? stateObject) => 188public static IPAddress[] GetHostAddresses(string hostNameOrAddress) 197/// An array of type <see cref="IPAddress"/> that holds the IP addresses for the host that is specified by the <paramref name="hostNameOrAddress"/> parameter. 199public static IPAddress[] GetHostAddresses(string hostNameOrAddress, AddressFamily family) 204IPAddress[] addresses; 205if (IPAddress.TryParse(hostNameOrAddress, out IPAddress? address)) 207if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) 213addresses = (family == AddressFamily.Unspecified || address.AddressFamily == family) ? new IPAddress[] { address } : Array.Empty<IPAddress>(); 224public static Task<IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress) => 225(Task<IPAddress[]>)GetHostEntryOrAddressesCoreAsync(hostNameOrAddress, justReturnParsedIp: true, throwOnIIPAny: true, justAddresses: true, AddressFamily.Unspecified, CancellationToken.None); 234/// type <see cref="IPAddress"/> that holds the IP addresses for the host that is specified by the <paramref name="hostNameOrAddress"/> parameter. 236public static Task<IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress, CancellationToken cancellationToken) => 237(Task<IPAddress[]>)GetHostEntryOrAddressesCoreAsync(hostNameOrAddress, justReturnParsedIp: true, throwOnIIPAny: true, justAddresses: true, AddressFamily.Unspecified, cancellationToken); 247/// type <see cref="IPAddress"/> that holds the IP addresses for the host that is specified by the <paramref name="hostNameOrAddress"/> parameter. 249public static Task<IPAddress[]> GetHostAddressesAsync(string hostNameOrAddress, AddressFamily family, CancellationToken cancellationToken = default) => 250(Task<IPAddress[]>)GetHostEntryOrAddressesCoreAsync(hostNameOrAddress, justReturnParsedIp: true, throwOnIIPAny: true, justAddresses: true, family, cancellationToken); 255public static IPAddress[] EndGetHostAddresses(IAsyncResult asyncResult) 261return TaskToAsyncResult.End<IPAddress[]>(asyncResult); 269if (IPAddress.TryParse(hostName, out IPAddress? address)) 298IPHostEntry ipHostEntry = GetHostEntryCore(IPAddress.Parse(address), AddressFamily.Unspecified); 305public static IPHostEntry GetHostByAddress(IPAddress address) 324if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostName, out IPAddress? address) && 365IPAddress? address = asyncState switch 367IPAddress a => a, 368KeyValuePair<IPAddress, AddressFamily> t => t.Key, 387private static IPAddress[] GetHostAddressesCore(string hostName, AddressFamily addressFamily, NameResolutionActivity? activityOrDefault = default) => 388(IPAddress[])GetHostEntryOrAddressesCore(hostName, justAddresses: true, addressFamily, activityOrDefault); 397IPAddress[] addresses = Array.Empty<IPAddress>(); 435SocketError errorCode = NameResolutionPal.TryGetAddrInfo(hostName, justAddresses, addressFamily, out string? newHostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode); 463private static IPHostEntry GetHostEntryCore(IPAddress address, AddressFamily addressFamily, NameResolutionActivity? activityOrDefault = default) => 466private static IPAddress[] GetHostAddressesCore(IPAddress address, AddressFamily addressFamily, NameResolutionActivity? activityOrDefault = default) => 467(IPAddress[])GetHostEntryOrAddressesCore(address, justAddresses: true, addressFamily, activityOrDefault); 470private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAddresses, AddressFamily addressFamily, NameResolutionActivity? activityOrDefault = default) 513errorCode = NameResolutionPal.TryGetAddrInfo(name, justAddresses, addressFamily, out string? hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode); 558Task.FromCanceled<IPAddress[]>(cancellationToken) : 565Task.FromResult((IPAddress[])resultOnFailure) : 572if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostName, out IPAddress? ipAddress)) 574if (throwOnIIPAny && (ipAddress.Equals(IPAddress.Any) || ipAddress.Equals(IPAddress.IPv6Any))) 583Task.FromResult(family == AddressFamily.Unspecified || ipAddress.AddressFamily == family ? new[] { ipAddress } : Array.Empty<IPAddress>()) : 587asyncState = family == AddressFamily.Unspecified ? (object)ipAddress : new KeyValuePair<IPAddress, AddressFamily>(ipAddress, family); 605? GetAddrInfoWithTelemetryAsync<IPAddress[]>(hostName, justAddresses, family, cancellationToken) 630IPAddress a => GetHostAddressesCore(a, AddressFamily.Unspecified, activity), 631KeyValuePair<IPAddress, AddressFamily> t => GetHostAddressesCore(t.Key, t.Value, activity), 641IPAddress a => GetHostEntryCore(a, AddressFamily.Unspecified, activity), 642KeyValuePair<IPAddress, AddressFamily> t => GetHostEntryCore(t.Key, t.Value, activity), 685private static IPHostEntry CreateHostEntryForAddress(IPAddress address) => 690AddressList = new IPAddress[] { address }

System\Net\IPHostEntry.cs (1)

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

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

56private static unsafe void ParseHostEntry(Interop.Sys.HostEntry hostEntry, bool justAddresses, out string? hostName, out string[] aliases, out IPAddress[] addresses) 64IPAddress[] localAddresses; 67localAddresses = Array.Empty<IPAddress>(); 96localAddresses = new IPAddress[nativeAddressCount]; 131public static unsafe SocketError TryGetAddrInfo(string name, bool justAddresses, AddressFamily addressFamily, out string? hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode) 146addresses = Array.Empty<IPAddress>(); 155public 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)

117var 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 SocketConfig GetSocketConfig(IPAddress address, byte[] buffer, int timeout, PingOptions? options) 43iph.TotalLength = OperatingSystem.IsFreeBSD() ? (ushort)IPAddress.HostToNetworkOrder((short)totalLength) : (ushort)totalLength; 245IPAddress address = ((IPEndPoint)socketConfig.EndPoint).Address; 250private static 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\Cookie.cs (1)

349&& !IPAddress.IsValid(host); // If host is an IP address, there should be an exact match.

System\Net\IPAddress.cs (37)

20public class IPAddress : ISpanFormattable, ISpanParsable<IPAddress>, IUtf8SpanFormattable, IUtf8SpanParsable<IPAddress> 22public static readonly IPAddress Any = new ReadOnlyIPAddress([0, 0, 0, 0]); 23public static readonly IPAddress Loopback = new ReadOnlyIPAddress([127, 0, 0, 1]); 24public static readonly IPAddress Broadcast = new ReadOnlyIPAddress([255, 255, 255, 255]); 25public static readonly IPAddress None = Broadcast; 29public static readonly IPAddress IPv6Any = new ReadOnlyIPAddress([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 0); 30public static readonly IPAddress IPv6Loopback = new ReadOnlyIPAddress([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 0); 31public static readonly IPAddress IPv6None = IPv6Any; 33private static readonly IPAddress s_loopbackMappedToIPv6 = new ReadOnlyIPAddress([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 127, 0, 0, 1], 0); 119/// Initializes a new instance of the <see cref='System.Net.IPAddress'/> 227/// <summary>Determines whether the provided span contains a valid <see cref="IPAddress"/>.</summary> 231/// <summary>Determines whether the provided span contains a valid <see cref="IPAddress"/>.</summary> 237/// Converts an IP address string to an <see cref='System.Net.IPAddress'/> instance. 240public static bool TryParse([NotNullWhen(true)] string? ipString, [NotNullWhen(true)] out IPAddress? address) 258public static bool TryParse(ReadOnlySpan<byte> utf8Text, [NotNullWhen(true)] out IPAddress? result) 264public static bool TryParse(ReadOnlySpan<char> ipSpan, [NotNullWhen(true)] out IPAddress? address) 271static bool IUtf8SpanParsable<IPAddress>.TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 275static bool IParsable<IPAddress>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 280static bool ISpanParsable<IPAddress>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [NotNullWhen(true)] out IPAddress? result) => 284public static IPAddress Parse(string ipString) 296public static IPAddress Parse(ReadOnlySpan<byte> utf8Text) 301public static IPAddress Parse(ReadOnlySpan<char> ipSpan) 307static IPAddress IUtf8SpanParsable<IPAddress>.Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider) => 312static IPAddress ISpanParsable<IPAddress>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) => 317static IPAddress IParsable<IPAddress>.Parse(string s, IFormatProvider? provider) => 565public static bool IsLoopback(IPAddress address) 682return comparand is IPAddress address && Equals(address); 685internal bool Equals(IPAddress comparand) 739public IPAddress MapToIPv6() 757public 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)); 302return (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 (21)

15/// Represents an IP network with an <see cref="IPAddress"/> containing the network prefix and an <see cref="int"/> defining the prefix length. 24private readonly IPAddress? _baseAddress; 27/// Gets the <see cref="IPAddress"/> that represents the prefix of the network. 29public IPAddress BaseAddress => _baseAddress ?? IPAddress.Any; 37/// Initializes a new instance of the <see cref="IPNetwork"/> class with the specified <see cref="IPAddress"/> and prefix length. 39/// <param name="baseAddress">The <see cref="IPAddress"/> that represents the prefix of the network.</param> 44public IPNetwork(IPAddress baseAddress, int prefixLength) 61/// Determines whether a given <see cref="IPAddress"/> is part of the network. 63/// <param name="address">The <see cref="IPAddress"/> to check.</param> 64/// <returns><see langword="true"/> if the <see cref="IPAddress"/> is part of the network; otherwise, <see langword="false"/>.</returns> 66public bool Contains(IPAddress address) 187if (IPAddress.TryParse(ipAddressSpan, out IPAddress? address) && 215if (IPAddress.TryParse(ipAddressSpan, out IPAddress? address) && 229private static int GetMaxPrefixLength(IPAddress baseAddress) => baseAddress.AddressFamily == AddressFamily.InterNetwork ? 32 : 128; 231private static IPAddress ClearNonZeroBitsAfterNetworkPrefix(IPAddress baseAddress, int prefixLength) 239return IPAddress.Any; 259return IPAddress.IPv6Any;

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)

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

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

150if (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)

1795IPAddress[] addresses = parameters.Async ? 1814static void BindHelper(ServicePoint servicePoint, ref IPAddress[] addresses, Socket socket, int port) 1822foreach (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)

365IPAddress.IsValid(sslAuthenticationOptions.TargetHost) || 446if (!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(); 874public void Connect(IPAddress address, int port) 918IPAddress? parsedAddress; 919if (IPAddress.TryParse(host, out parsedAddress)) 925IPAddress[] addresses = Dns.GetHostAddresses(host); 930public void Connect(IPAddress[] addresses, int port) 955foreach (IPAddress address in addresses) 2454public IAsyncResult BeginConnect(IPAddress address, int port, AsyncCallback? requestCallback, object? state) => 2457public IAsyncResult BeginConnect(IPAddress[] addresses, int port, AsyncCallback? requestCallback, object? state) => 3335IPAddress addr = ip.Address; 3569IPAddress? boundAddress = ipEndPoint?.Address; 3576if ((boundAddress != null && IsDualMode && (boundAddress.IsIPv4MappedToIPv6 || boundAddress.Equals(IPAddress.IPv6Any)))) 3873IPAddress address = ipEndpoint.Address; 3874return IPAddress.Any.Equals(address) || IPAddress.IPv6Any.Equals(address) || s_IPAddressAnyMapToIPv6.Equals(address);

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

109public Task ConnectAsync(IPAddress address, int port) => ConnectAsync(new IPEndPoint(address, port)); 118public ValueTask ConnectAsync(IPAddress address, int port, CancellationToken cancellationToken) => ConnectAsync(new IPEndPoint(address, port), cancellationToken); 126public Task ConnectAsync(IPAddress[] addresses, int port) => ConnectAsync(addresses, port, CancellationToken.None).AsTask(); 135public ValueTask ConnectAsync(IPAddress[] addresses, int port, CancellationToken cancellationToken) 165async ValueTask Core(IPAddress[] addresses, int port, CancellationToken cancellationToken) 169foreach (IPAddress address in addresses) 216EndPoint ep = IPAddress.TryParse(host, out IPAddress? parsedAddress) ? (EndPoint)

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

696Task<IPAddress[]> addressesTask = Dns.GetHostAddressesAsync(endPoint.Host, endPoint.AddressFamily, cancellationToken); 717async Task Core(MultiConnectSocketAsyncEventArgs internalArgs, Task<IPAddress[]> addressesTask, int port, SocketType socketType, ProtocolType protocolType, CancellationToken cancellationToken) 726foreach (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)

1675/// If the hostname parses as an <see cref="IPAddress"/> then IPAddress matching is done; 1734/// <seealso cref="IPAddress.TryParse(string, out IPAddress)"/> 1739IPAddress? ipAddress; 1741if (!IPAddress.TryParse(hostname, out ipAddress)) 1781foreach (IPAddress sanEntry in san.EnumerateIPAddresses())

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

85public IEnumerable<IPAddress> EnumerateIPAddresses() 92private static IEnumerable<IPAddress> EnumerateIPAddresses(List<GeneralNameAsn> decoded)

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

54public static async Task<IPAddress[]> ResolveAsync(Uri uri) 57IPAddress[] hostAddresses = null; 111internal static async Task<IPAddress[]> LookupHostName(string hostName) 118private IPAddress[] _addressList; 120public DnsCacheEntry(IPAddress[] addressList, DateTime timeStamp) 126public IPAddress[] AddressList

System\ServiceModel\Channels\SocketConnection.cs (13)

808private async Task<IConnection> CreateConnectionAsync(IPAddress address, int port) 872private static async Task<IPAddress[]> GetIPAddressesAsync(Uri uri) 877IPAddress ipAddress = IPAddress.Parse(uri.DnsSafeHost); 878return new IPAddress[] { ipAddress }; 885return new IPAddress[] { IPAddress.IPv6Loopback, IPAddress.Loopback }; 889return new IPAddress[] { IPAddress.Loopback }; 893IPAddress[] addresses = null; 914private static TimeoutException CreateTimeoutException(Uri uri, TimeSpan timeout, IPAddress[] addresses, int invalidAddressCount, 940IPAddress[] addresses = await GetIPAddressesAsync(uri);

Startup.cs (2)

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

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

121IPAddress ipAddress = GetIPAddressFromString (val); 220private 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 =>