public static IAsyncResult BeginResolve(string hostName, AsyncCallback requestCallback, object stateObject)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(null, hostName);
}
NameResolutionPal.EnsureSocketsAreInitialized();
IAsyncResult asyncResult = HostResolutionBeginHelper(hostName, false, false, false, requestCallback, stateObject);
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(null, asyncResult);
}
return(asyncResult);
} // BeginResolve
} // BeginResolve
public static IAsyncResult BeginGetHostEntry(IPAddress address, AsyncCallback requestCallback, object stateObject)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(null, address);
}
NameResolutionPal.EnsureSocketsAreInitialized();
IAsyncResult asyncResult = HostResolutionBeginHelper(address, true, true, requestCallback, stateObject);
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(null, asyncResult);
}
return(asyncResult);
} // BeginResolve
} // GetHostByAddress
// Does internal IPAddress reverse and then forward lookups (for Legacy and current public methods).
private static IPHostEntry InternalGetHostByAddress(IPAddress address)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(null, address);
}
//
// Try to get the data for the host from it's address
//
// We need to call getnameinfo first, because getaddrinfo w/ the ipaddress string
// will only return that address and not the full list.
// Do a reverse lookup to get the host name.
SocketError errorCode;
int nativeErrorCode;
string name = NameResolutionPal.TryGetNameInfo(address, out errorCode, out nativeErrorCode);
if (errorCode == SocketError.Success)
{
// Do the forward lookup to get the IPs for that host name
IPHostEntry hostEntry;
errorCode = NameResolutionPal.TryGetAddrInfo(name, out hostEntry, out nativeErrorCode);
if (errorCode == SocketError.Success)
{
return(hostEntry);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(null, SocketExceptionFactory.CreateSocketException(errorCode, nativeErrorCode));
}
// One of two things happened:
// 1. There was a ptr record in dns, but not a corollary A/AAA record.
// 2. The IP was a local (non-loopback) IP that resolved to a connection specific dns suffix.
// - Workaround, Check "Use this connection's dns suffix in dns registration" on that network
// adapter's advanced dns settings.
// Just return the resolved host name and no IPs.
return(hostEntry);
}
throw SocketExceptionFactory.CreateSocketException(errorCode, nativeErrorCode);
} // InternalGetHostByAddress
public static IPHostEntry Resolve(string hostName)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Socket, "DNS", "Resolve", hostName);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostName == null)
{
throw new ArgumentNullException(nameof(hostName));
}
// See if it's an IP Address.
IPAddress address;
IPHostEntry ipHostEntry;
if (IPAddress.TryParse(hostName, out address) && (address.AddressFamily != AddressFamily.InterNetworkV6 || SocketProtocolSupportPal.OSSupportsIPv6))
{
try
{
ipHostEntry = InternalGetHostByAddress(address, false);
}
catch (SocketException ex)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.PrintError(NetEventSource.ComponentType.Socket, "DNS", "DNS.Resolve", ex.Message);
}
ipHostEntry = NameResolutionUtilities.GetUnresolvedAnswer(address);
}
}
else
{
ipHostEntry = InternalGetHostByName(hostName, false);
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Socket, "DNS", "Resolve", ipHostEntry);
}
return(ipHostEntry);
}
public static IPHostEntry GetHostByName(string hostName)
{
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostName == null)
{
throw new ArgumentNullException(nameof(hostName));
}
// See if it's an IP Address.
IPAddress address;
if (IPAddress.TryParse(hostName, out address))
{
return(NameResolutionUtilities.GetUnresolvedAnswer(address));
}
return(InternalGetHostByName(hostName));
}
public static IPHostEntry Resolve(string hostName)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(hostName, hostName);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostName is null)
{
throw new ArgumentNullException(nameof(hostName));
}
// See if it's an IP Address.
IPHostEntry ipHostEntry;
if (IPAddress.TryParse(hostName, out IPAddress? address) &&
(address.AddressFamily != AddressFamily.InterNetworkV6 || SocketProtocolSupportPal.OSSupportsIPv6))
{
try
{
ipHostEntry = GetHostEntryCore(address);
}
catch (SocketException ex)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(hostName, ex);
}
ipHostEntry = CreateHostEntryForAddress(address);
}
}
else
{
ipHostEntry = GetHostEntryCore(hostName);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(hostName, ipHostEntry);
}
return(ipHostEntry);
}
public static Task <IPHostEntry> GetHostEntryAsync(IPAddress address)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(null, address);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (address is null)
{
throw new ArgumentNullException(nameof(address));
}
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
throw new ArgumentException(SR.net_invalid_ip_addr, nameof(address));
}
return(RunAsync(s => GetHostEntryCore((IPAddress)s), address));
}
public static IPHostEntry GetHostByAddress(IPAddress address)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(address, address);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (address is null)
{
throw new ArgumentNullException(nameof(address));
}
IPHostEntry ipHostEntry = GetHostEntryCore(address);
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(address, ipHostEntry);
}
return(ipHostEntry);
}
public static IPHostEntry GetHostByAddress(string address)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(null, address);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
IPHostEntry ipHostEntry = InternalGetHostByAddress(IPAddress.Parse(address));
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(null, ipHostEntry);
}
return(ipHostEntry);
} // GetHostByAddress
public static IPHostEntry GetHostEntry(string hostNameOrAddress)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(hostNameOrAddress, hostNameOrAddress);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostNameOrAddress is null)
{
throw new ArgumentNullException(nameof(hostNameOrAddress));
}
// See if it's an IP Address.
IPHostEntry ipHostEntry;
if (IPAddress.TryParse(hostNameOrAddress, out IPAddress? address))
{
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(address, $"Invalid address '{address}'");
}
throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
}
ipHostEntry = GetHostEntryCore(address);
}
else
{
ipHostEntry = GetHostEntryCore(hostNameOrAddress);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(hostNameOrAddress, $"{ipHostEntry} with {ipHostEntry.AddressList.Length} entries");
}
return(ipHostEntry);
}
public static IPAddress[] GetHostAddresses(string hostNameOrAddress)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(hostNameOrAddress, hostNameOrAddress);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostNameOrAddress is null)
{
throw new ArgumentNullException(nameof(hostNameOrAddress));
}
// See if it's an IP Address.
IPAddress[] addresses;
if (IPAddress.TryParse(hostNameOrAddress, out IPAddress? address))
{
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Error(address, $"Invalid address '{address}'");
}
throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
}
addresses = new IPAddress[] { address };
}
else
{
addresses = GetHostAddressesCore(hostNameOrAddress);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(hostNameOrAddress, addresses);
}
return(addresses);
}
public static IPHostEntry GetHostByAddress(IPAddress address)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Socket, "DNS", "GetHostByAddress", "");
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (address == null)
{
throw new ArgumentNullException(nameof(address));
}
IPHostEntry ipHostEntry = InternalGetHostByAddress(address, false);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Socket, "DNS", "GetHostByAddress", ipHostEntry);
}
return(ipHostEntry);
} // GetHostByAddress
} // GetHostEntry
public static IPAddress[] GetHostAddresses(string hostNameOrAddress)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Socket, "DNS", "GetHostAddresses", hostNameOrAddress);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostNameOrAddress == null)
{
throw new ArgumentNullException(nameof(hostNameOrAddress));
}
// See if it's an IP Address.
IPAddress address;
IPAddress[] addresses;
if (IPAddress.TryParse(hostNameOrAddress, out address))
{
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
}
addresses = new IPAddress[] { address };
}
else
{
// InternalGetHostByName works with IP addresses (and avoids a reverse-lookup), but we need
// explicit handling in order to do the ArgumentException and guarantee the behavior.
addresses = InternalGetHostByName(hostNameOrAddress, true).AddressList;
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Socket, "DNS", "GetHostAddresses", addresses);
}
return(addresses);
}
} // EndGetHostByName()
public static IPHostEntry GetHostEntry(string hostNameOrAddress)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Socket, "DNS", "GetHostEntry", hostNameOrAddress);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostNameOrAddress == null)
{
throw new ArgumentNullException(nameof(hostNameOrAddress));
}
// See if it's an IP Address.
IPAddress address;
IPHostEntry ipHostEntry;
if (IPAddress.TryParse(hostNameOrAddress, out address))
{
if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
{
throw new ArgumentException(SR.Format(SR.net_invalid_ip_addr, nameof(hostNameOrAddress)));
}
ipHostEntry = InternalGetHostByAddress(address, true);
}
else
{
ipHostEntry = InternalGetHostByName(hostNameOrAddress, true);
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Socket, "DNS", "GetHostEntry", ipHostEntry);
}
return(ipHostEntry);
}
/// <summary>Gets the host name of the local machine.</summary>
public static string GetHostName()
{
ValueStopwatch stopwatch = NameResolutionTelemetry.Log.BeforeResolution(string.Empty);
string name;
try
{
name = NameResolutionPal.GetHostName();
}
catch when(LogFailure(stopwatch))
{
Debug.Fail("LogFailure should return false");
throw;
}
NameResolutionTelemetry.Log.AfterResolution(stopwatch, successful: true);
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Info(null, name);
}
return(name);
}
private static IPHostEntry InternalGetHostByName(string hostName)
{
if (NetEventSource.IsEnabled)
{
NetEventSource.Enter(null, hostName);
}
IPHostEntry ipHostEntry = null;
ValidateHostName(hostName);
int nativeErrorCode;
SocketError errorCode = NameResolutionPal.TryGetAddrInfo(hostName, out ipHostEntry, out nativeErrorCode);
if (errorCode != SocketError.Success)
{
throw SocketExceptionFactory.CreateSocketException(errorCode, nativeErrorCode);
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Exit(null, ipHostEntry);
}
return(ipHostEntry);
} // GetHostByName
private static object GetHostEntryOrAddressesCore(string hostName, bool justAddresses)
{
ValidateHostName(hostName);
SocketError errorCode = NameResolutionPal.TryGetAddrInfo(hostName, justAddresses, out string?newHostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode);
} // InternalGetHostByAddress
/*****************************************************************************
* Function : gethostname
*
* Abstract: Queries the hostname from DNS
*
* Input Parameters:
*
* Returns: String
******************************************************************************/
/// <devdoc>
/// <para>Gets the host name of the local machine.</para>
/// </devdoc>
public static string GetHostName()
{
GlobalLog.Print("Dns.GetHostName");
return(NameResolutionPal.GetHostName());
}
internal static IPHostEntry InternalGetHostByName(string hostName, bool includeIPv6)
{
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Enter(NetEventSource.ComponentType.Socket, "DNS", "GetHostByName", hostName);
}
IPHostEntry ipHostEntry = null;
if (GlobalLog.IsEnabled)
{
GlobalLog.Print("Dns.GetHostByName: " + hostName);
}
NameResolutionPal.EnsureSocketsAreInitialized();
if (hostName.Length > MaxHostName || // If 255 chars, the last one must be a dot.
hostName.Length == MaxHostName && hostName[MaxHostName - 1] != '.')
{
throw new ArgumentOutOfRangeException(nameof(hostName), SR.Format(SR.net_toolong,
"hostName", MaxHostName.ToString(NumberFormatInfo.CurrentInfo)));
}
//
// IPv6 Changes: IPv6 requires the use of getaddrinfo() rather
// than the traditional IPv4 gethostbyaddr() / gethostbyname().
// getaddrinfo() is also protocol independent in that it will also
// resolve IPv4 names / addresses. As a result, it is the preferred
// resolution mechanism on platforms that support it (Windows 5.1+).
// If getaddrinfo() is unsupported, IPv6 resolution does not work.
//
// Consider : If IPv6 is disabled, we could detect IPv6 addresses
// and throw an unsupported platform exception.
//
// Note : Whilst getaddrinfo is available on WinXP+, we only
// use it if IPv6 is enabled (platform is part of that
// decision). This is done to minimize the number of
// possible tests that are needed.
//
if (includeIPv6 || SocketProtocolSupportPal.OSSupportsIPv6)
{
//
// IPv6 enabled: use getaddrinfo() to obtain DNS information.
//
int nativeErrorCode;
SocketError errorCode = NameResolutionPal.TryGetAddrInfo(hostName, out ipHostEntry, out nativeErrorCode);
if (errorCode != SocketError.Success)
{
throw new InternalSocketException(errorCode, nativeErrorCode);
}
}
else
{
ipHostEntry = NameResolutionPal.GetHostByName(hostName);
}
if (NetEventSource.Log.IsEnabled())
{
NetEventSource.Exit(NetEventSource.ComponentType.Socket, "DNS", "GetHostByName", ipHostEntry);
}
return(ipHostEntry);
} // GetHostByName
} // GetHostByName
// Does internal IPAddress reverse and then forward lookups (for Legacy and current public methods).
internal static IPHostEntry InternalGetHostByAddress(IPAddress address, bool includeIPv6)
{
GlobalLog.Print("Dns.InternalGetHostByAddress: " + address.ToString());
//
// IPv6 Changes: We need to use the new getnameinfo / getaddrinfo functions
// for resolution of IPv6 addresses.
//
if (SocketProtocolSupportPal.OSSupportsIPv6 || includeIPv6)
{
//
// Try to get the data for the host from it's address
//
// We need to call getnameinfo first, because getaddrinfo w/ the ipaddress string
// will only return that address and not the full list.
// Do a reverse lookup to get the host name.
SocketError errorCode;
int nativeErrorCode;
string name = NameResolutionPal.TryGetNameInfo(address, out errorCode, out nativeErrorCode);
if (errorCode == SocketError.Success)
{
// Do the forward lookup to get the IPs for that host name
IPHostEntry hostEntry;
errorCode = NameResolutionPal.TryGetAddrInfo(name, out hostEntry, out nativeErrorCode);
if (errorCode == SocketError.Success)
{
return(hostEntry);
}
if (Logging.On)
{
Logging.Exception(Logging.Sockets, "DNS",
"InternalGetHostByAddress", new InternalSocketException(errorCode, nativeErrorCode));
}
// One of two things happened:
// 1. There was a ptr record in dns, but not a corollary A/AAA record.
// 2. The IP was a local (non-loopback) IP that resolved to a connection specific dns suffix.
// - Workaround, Check "Use this connection's dns suffix in dns registration" on that network
// adapter's advanced dns settings.
// Just return the resolved host name and no IPs.
return(hostEntry);
}
throw new InternalSocketException(errorCode, nativeErrorCode);
}
//
// If IPv6 is not enabled (maybe config switch) but we've been
// given an IPv6 address then we need to bail out now.
//
else
{
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
//
// Protocol not supported
//
throw new SocketException((int)SocketError.ProtocolNotSupported);
}
//
// Use gethostbyaddr() to try to resolve the IP address
//
// End IPv6 Changes
//
return(NameResolutionPal.GetHostByAddr(address));
}
} // InternalGetHostByAddress
// Helpers for async GetHostByName, ResolveToAddresses, and Resolve - they're almost identical
// If hostName is an IPString and justReturnParsedIP==true then no reverse lookup will be attempted, but the original address is returned.
private static IAsyncResult HostResolutionBeginHelper(string hostName, bool justReturnParsedIp, bool throwOnIIPAny, AsyncCallback requestCallback, object state)
{
if (hostName == null)
{
throw new ArgumentNullException(nameof(hostName));
}
if (NetEventSource.IsEnabled)
{
NetEventSource.Info(null, hostName);
}
// See if it's an IP Address.
IPAddress ipAddress;
DnsResolveAsyncResult asyncResult;
if (IPAddress.TryParse(hostName, out ipAddress))
{
if (throwOnIIPAny && (ipAddress.Equals(IPAddress.Any) || ipAddress.Equals(IPAddress.IPv6Any)))
{
throw new ArgumentException(SR.net_invalid_ip_addr, nameof(hostName));
}
asyncResult = new DnsResolveAsyncResult(ipAddress, null, state, requestCallback);
if (justReturnParsedIp)
{
IPHostEntry hostEntry = NameResolutionUtilities.GetUnresolvedAnswer(ipAddress);
asyncResult.StartPostingAsyncOp(false);
asyncResult.InvokeCallback(hostEntry);
asyncResult.FinishPostingAsyncOp();
return(asyncResult);
}
}
else
{
asyncResult = new DnsResolveAsyncResult(hostName, null, state, requestCallback);
}
// Set up the context, possibly flow.
asyncResult.StartPostingAsyncOp(false);
// If the OS supports it and 'hostName' is not an IP Address, resolve the name asynchronously
// instead of calling the synchronous version in the ThreadPool.
if (NameResolutionPal.SupportsGetAddrInfoAsync && ipAddress == null)
{
ValidateHostName(hostName);
NameResolutionPal.GetAddrInfoAsync(asyncResult);
}
else
{
// Start the resolve.
Task.Factory.StartNew(
s => ResolveCallback(s),
asyncResult,
CancellationToken.None,
TaskCreationOptions.DenyChildAttach,
TaskScheduler.Default);
}
// Finish the flowing, maybe it completed? This does nothing if we didn't initiate the flowing above.
asyncResult.FinishPostingAsyncOp();
return(asyncResult);
}
