/// <summary>
/// 获取本地的IP地址
/// </summary>
/// <param name="ipv4">是否ipv4</param>
/// <returns></returns>
public static async Task <string> GetIpAddressAsync(bool ipv4 = true)
{
var client = new LookupClient();
var hostEntry = await client.GetHostEntryAsync(Dns.GetHostName());
IPAddress ipaddress = null;
if (ipv4)
{
ipaddress = (from ip in hostEntry.AddressList where
(!IPAddress.IsLoopback(ip) && ip.AddressFamily == AddressFamily.InterNetwork)
select ip)
.FirstOrDefault();
}
else
{
ipaddress = (from ip in hostEntry.AddressList where
(!IPAddress.IsLoopback(ip) && ip.AddressFamily == AddressFamily.InterNetworkV6)
select ip)
.FirstOrDefault();
}
if (ipaddress != null)
{
return(ipaddress.ToString());
}
return(string.Empty);
}
public async Task GetHostEntryAsync_ByIp_NoHost()
{
var client = new LookupClient();
var result = await client.GetHostEntryAsync("1.0.0.0");
Assert.Null(result);
}
public async Task TestQueryAsync()
{
await _client.QueryAsync("domain", QueryType.A);
await _client.QueryAsync("domain", QueryType.A, QueryClass.IN);
await _client.QueryAsync("domain", QueryType.A, cancellationToken : default(CancellationToken));
await _client.QueryAsync("domain", QueryType.A, QueryClass.IN, default(CancellationToken));
await _client.QueryReverseAsync(IPAddress.Loopback);
await _client.QueryReverseAsync(IPAddress.Loopback, default(CancellationToken));
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A);
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A, cancellationToken : default(CancellationToken));
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A, QueryClass.IN);
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns.Address }, "domain", QueryType.A, QueryClass.IN, default(CancellationToken));
await _client.QueryServerReverseAsync(new[] { NameServer.GooglePublicDns.Address }, IPAddress.Loopback);
await _client.QueryServerReverseAsync(new[] { NameServer.GooglePublicDns.Address }, IPAddress.Loopback, default(CancellationToken));
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A);
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A, cancellationToken : default(CancellationToken));
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A, QueryClass.IN);
await _client.QueryServerAsync(new[] { NameServer.GooglePublicDns }, "domain", QueryType.A, QueryClass.IN, default(CancellationToken));
await _client.QueryServerReverseAsync(new[] { NameServer.GooglePublicDns }, IPAddress.Loopback);
await _client.QueryServerReverseAsync(new[] { NameServer.GooglePublicDns }, IPAddress.Loopback, default(CancellationToken));
await _client.GetHostEntryAsync(IPAddress.Loopback);
await _client.GetHostEntryAsync("localhost");
await _client.GetHostNameAsync(IPAddress.Loopback);
await _client.ResolveServiceAsync("domain", "srv", tag : null);
}
public async Task GetHostEntry_ExampleSub()
{
var client = new LookupClient(NameServer.GooglePublicDns);
var hostEntry = await client.GetHostEntryAsync("mail.google.com");
Assert.EndsWith("google.com", hostEntry.Aliases.First(), StringComparison.OrdinalIgnoreCase);
Assert.Equal("mail.google.com", hostEntry.HostName);
Assert.True(hostEntry.AddressList.Length > 0);
}
public async Task GetHostEntryAsync_ByIp()
{
var source = Dns.GetHostEntryAsync("localhost").Result;
var client = new LookupClient();
var result = await client.GetHostEntryAsync(source.AddressList.First());
Assert.True(result.AddressList.Length == 1);
Assert.True(result.Aliases.Length == 0);
}
public async Task GetHostEntry_ExampleSub()
{
var client = new LookupClient();
var hostEntry = await client.GetHostEntryAsync("mail.google.com");
Assert.EndsWith("google.com", hostEntry.Aliases.First());
Assert.Equal("mail.google.com", hostEntry.HostName);
Assert.True(hostEntry.AddressList.Length > 0);
}
public async Task GetHostEntryAsync_ByName_OneIp_ManyAliases()
{
var client = new LookupClient(NameServer.GooglePublicDns);
var result = await client.GetHostEntryAsync("dnsclient.michaco.net");
Assert.True(result.AddressList.Length == 1);
Assert.True(result.Aliases.Length > 1);
Assert.Equal("dnsclient.michaco.net", result.HostName);
}
public async Task GetHostEntryAsync_ByName_ManyIps_NoAlias()
{
var client = new LookupClient(NameServer.GooglePublicDns);
var result = await client.GetHostEntryAsync("google.com");
Assert.True(result.AddressList.Length > 1);
Assert.True(result.Aliases.Length == 0);
Assert.Equal("google.com", result.HostName);
}
public async Task GetHostEntryAsync_ByName_HostDoesNotExist()
{
var client = new LookupClient();
var result = await client.GetHostEntryAsync("lolhost");
Assert.True(result.AddressList.Length == 0);
Assert.True(result.Aliases.Length == 0);
Assert.Equal("lolhost", result.HostName);
}
public async Task GetHostEntryAsync_ByManyIps()
{
var client = new LookupClient(NameServer.GooglePublicDns);
var nsServers = client.Query("google.com", QueryType.NS).Answers.NsRecords().ToArray();
Assert.True(nsServers.Length > 0, "Should have more than 0 NS servers");
foreach (var server in nsServers)
{
var ipAddress = (await client.GetHostEntryAsync(server.NSDName)).AddressList.First();
var result = await client.GetHostEntryAsync(ipAddress);
Assert.True(result.AddressList.Length >= 1, "Revers should have found at least one ip");
Assert.True(result.AddressList.Contains(ipAddress), "Result should contain the NSDName address");
Assert.True(result.Aliases.Length == 0, "There shouldn't be an alias");
// expecting always the name without . at the end!
Assert.Equal(server.NSDName.Value.Substring(0, server.NSDName.Value.Length - 1), result.HostName);
}
}
public async Task GetHostEntryAsync_ByName_EmptyString()
{
var client = new LookupClient();
Func <Task> act = async() => await client.GetHostEntryAsync("");
var ex = await Record.ExceptionAsync(act);
Assert.NotNull(ex);
Assert.Contains("hostNameOrAddress", ex.Message);
}
public async Task GetHostEntryAsync_ByManyIps()
{
var client = new LookupClient();
var nsServers = client.Query("google.com", QueryType.NS).Answers.NsRecords().ToArray();
Assert.True(nsServers.Length > 0);
foreach (var server in nsServers)
{
var ipAddress = (await client.GetHostEntryAsync(server.NSDName)).AddressList.First();
var result = await client.GetHostEntryAsync(ipAddress);
Assert.True(result.AddressList.Length >= 1);
Assert.True(result.AddressList.Contains(ipAddress));
Assert.True(result.Aliases.Length == 0);
// expecting always the name without . at the end!
Assert.Equal(server.NSDName.Value.Substring(0, server.NSDName.Value.Length - 1), result.HostName);
}
}
public async Task GetHostEntryAsync_ByName_HostDoesNotExist_WithThrow()
{
var client = new LookupClient(
new LookupClientOptions()
{
ThrowDnsErrors = true
});
var ex = await Assert.ThrowsAnyAsync <DnsResponseException>(() => client.GetHostEntryAsync("lolhost"));
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
public async Task GetHostEntryAsync_ByName_EmptyString()
{
var client = new LookupClient();
Func <Task> act = async() => await client.GetHostEntryAsync("");
// ReSharper disable once PossibleNullReferenceException <-- ???
var ex = await Record.ExceptionAsync(act);
Assert.NotNull(ex);
Assert.Contains("hostNameOrAddress", ex.Message);
}
public async Task GetHostEntryAsync_ByIp_NoHost_WithThrow()
{
var client = new LookupClient()
{
ThrowDnsErrors = true
};
Func <Task> act = async() => await client.GetHostEntryAsync("1.0.0.0");
var ex = await Record.ExceptionAsync(act) as DnsResponseException;
Assert.NotNull(ex);
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
public async Task GetHostEntryAsync_ByName_HostDoesNotExist_WithThrow()
{
var client = new LookupClient
{
ThrowDnsErrors = true
};
Func <Task> act = async() => await client.GetHostEntryAsync("lolhost");
// ReSharper disable once PossibleNullReferenceException <-- ???
var ex = await Record.ExceptionAsync(act) as DnsResponseException;
Assert.NotNull(ex);
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
public async Task Test_ResolveDomainName()
{
DnsClient.LookupClient lookupClient = new LookupClient();
var hostEntry = await lookupClient.GetHostEntryAsync(Constants.TEST_REVERSEDNS_HOSTNAME);
var ipAddress = hostEntry.AddressList.First();
ReverseDnsService reverseDnsService = new ReverseDnsService(lookupClient, null);
var response = await reverseDnsService.ResolveDomainNameAsync(ipAddress);
Assert.IsNotNull(response, $"Error getting domain name for: {ipAddress}");
ipAddress = IPAddress.Parse("127.0.0.2");
response = await reverseDnsService.ResolveDomainNameAsync(ipAddress);
Assert.AreEqual(null, response, $"Invalid result for: {ipAddress}");
}
/// <summary>
/// Task to asynchronously resolve an ip address from hostname.
/// </summary>
/// <param name="hostname">Hostname to resolve.</param>
/// <param name="preferIPv4">Prefer IPv4 address.</param>
/// <returns>Resovled <see cref="IPAddress"/>.</returns>
public async static Task <IPAddress> ResolveIPAddress(string hostname, bool preferIPv4 = true)
{
// Append dns suffix to hostname
if (hostname.IndexOf(".", StringComparison.OrdinalIgnoreCase) == -1)
{
var dnsSuffix = IPGlobalProperties.GetIPGlobalProperties().DomainName;
if (!string.IsNullOrEmpty(dnsSuffix))
{
hostname += $".{dnsSuffix}";
}
}
try
{
// Try to resolve the hostname
var ipHostEntrys = await DnsLookupClient.GetHostEntryAsync(hostname);
if (ipHostEntrys.AddressList.Length != 0)
{
foreach (var ip in ipHostEntrys.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork && preferIPv4)
{
return(ip);
}
if (ip.AddressFamily == AddressFamily.InterNetworkV6 && !preferIPv4)
{
return(ip);
}
}
// Fallback --> If we could not resolve our prefered ip protocol for the hostname
foreach (var ip in ipHostEntrys.AddressList)
{
return(ip);
}
}
}
#pragma warning disable CA1031 // Null will be returned on error.
catch { }
#pragma warning restore CA1031
return(null);
}
public async Task InitializeAsync(TimeSpan?timeout = null)
{
try
{
var lookup = new LookupClient(this.NameserverV4)
{
UseCache = false,
Timeout = timeout ?? TimeSpan.FromSeconds(3),
};
var nsLookupResult = await lookup.QueryAsync("zen.spamhaus.org", QueryType.NS);
if (nsLookupResult.Answers.Count > 0)
{
var nsRndResult = nsLookupResult.Answers.ElementAt((int)(DateTime.UtcNow.Ticks % nsLookupResult.Answers.Count));
if (nsRndResult is NsRecord nsRecord)
{
var hostV4List = new List <IPAddress>();
var hostV6List = new List <IPAddress>();
var hostEntryResult = await lookup.GetHostEntryAsync(nsRecord.NSDName);
foreach (var item in hostEntryResult.AddressList)
{
if (item.AddressFamily == AddressFamily.InterNetwork)
{
hostV4List.Add(item);
}
else if (item.AddressFamily == AddressFamily.InterNetworkV6)
{
hostV6List.Add(item);
}
}
this.spamhausNameserverV4 = hostV4List.ToArray();
this.spamhausNameserverV6 = hostV6List.ToArray();
}
}
}
catch (Exception)
{
if (this.QuietMode == false)
{
throw;
}
}
}
/// <summary>
/// 获取本地的IP地址
/// </summary>
/// <param name="ipv4">是否ipv4</param>
/// <returns></returns>
public static async Task <string> GetIpAddressAsync(bool ipv4 = true)
{
var client = new LookupClient();
var hostEntry = await client.GetHostEntryAsync(Dns.GetHostName());
IPAddress ipAddress = null;
if (ipv4)
{
ipAddress = hostEntry
.AddressList
.Where(ip => !IPAddress.IsLoopback(ip) && ip.AddressFamily == AddressFamily.InterNetwork)
.FirstOrDefault();
}
else
{
ipAddress = hostEntry
.AddressList
.Where(ip => !IPAddress.IsLoopback(ip) && ip.AddressFamily == AddressFamily.InterNetworkV6)
.FirstOrDefault();
}
return(ipAddress?.ToString());
}
public async Task GetHostEntryAsync_ByName_EmptyString()
{
var client = new LookupClient(NameServer.GooglePublicDns);
await Assert.ThrowsAsync <ArgumentNullException>("hostNameOrAddress", () => client.GetHostEntryAsync(""));
}
