IPAddress LookUpAsync(string Host)
{
var lookup = new LookupClient();
var result = lookup.Query(Host, QueryType.A);
var record = result.Answers.ARecords().FirstOrDefault();
var addr = record?.Address;
if (addr == null)
{
throw new ArgumentNullException($"LookUp错误:没有返回{Host}的IP地址。");
}
return(addr);
}
public void Lookup_ThrowDnsErrors_Sync()
{
var client = new LookupClient()
{
ThrowDnsErrors = true
};
Action act = () => client.Query("lalacom", (QueryType)12345);
var ex = Record.Exception(act) as DnsResponseException;
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
static STUNDns()
{
var nameServers = NameServer.ResolveNameServers(skipIPv6SiteLocal: true, fallbackToGooglePublicDns: true);
LookupClientOptions clientOptions = new LookupClientOptions(nameServers.ToArray())
{
Retries = DNS_RETRIES_PER_SERVER,
Timeout = TimeSpan.FromSeconds(DNS_TIMEOUT_SECONDS),
UseCache = true,
UseTcpFallback = false
};
_lookupClient = new LookupClient(clientOptions);
}
public void GetHostEntry_ByName_ManyAliases()
{
var client = new LookupClient(new LookupClientOptions(NameServer.GooglePublicDns)
{
ThrowDnsErrors = true
});
var result = client.GetHostEntry("dnsclient.michaco.net");
Assert.True(result.AddressList.Length >= 1);
Assert.True(result.Aliases.Length > 1);
Assert.Equal("dnsclient.michaco.net", result.HostName);
}
public void Lookup_ThrowDnsErrors()
{
var client = new LookupClient()
{
ThrowDnsErrors = true
};
Action act = () => client.QueryAsync("lalacom", (QueryType)12345).GetAwaiter().GetResult();
var ex = Record.Exception(act) as DnsResponseException;
Assert.Equal(ex.Code, DnsResponseCode.NotExistentDomain);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvcCore(options =>
{
});
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8600);
var lookup = new LookupClient(endpoint);
lookup.UseCache = true;
lookup.MinimumCacheTimeout = TimeSpan.FromMilliseconds(1);
services.AddSingleton(lookup);
}
public async Task Test()
{
try
{
var dnsQuery = new LookupClient(IPAddress.Parse("127.0.0.1"), 8600);
var hostList = await dnsQuery.ResolveServiceAsync("service.consul", "UnitTestService");
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task Lookup_GetHostAddresses_Local()
{
var client = new LookupClient();
var result = await client.QueryAsync("localhost", ARecord.ResourceRecordType);
var answer = result.Answers.OfType <ARecord>().First();
Assert.Equal("127.0.0.1", answer.Address.ToString());
Assert.Equal(QueryClass.In, result.Questions.First().QuestionClass);
Assert.Equal(ARecord.ResourceRecordType, result.Questions.First().QuestionType);
Assert.True(result.Header.AnswerCount > 0);
}
public void Lookup_ThrowDnsErrors_Sync()
{
var client = new LookupClient
{
ThrowDnsErrors = true
};
Action act = () => client.Query("lalacom", new PseudoResourceRecordType("", 12345));
var ex = Record.Exception(act) as DnsResponseException ?? throw new Exception();
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
//This is unused but is cool and i might want to use it when importing server data that doesnt say whether or not it has DNSSEC?
public async Task <bool> ServerHasDNSSEC(IPAddress serverAddress, TimeSpan timeout, int retries = 0)
{
LookupClientOptions options = new LookupClientOptions(new IPAddress[] { serverAddress })
{
Timeout = timeout,
Retries = retries,
RequestDnsSecRecords = true
};
var client = new LookupClient(options);
var response = await client.QueryAsync("www.dnssec-tools.org", QueryType.ANY);
return(response.Header.IsAuthenticData);
}
public void Lookup_GetHostAddresses_Local_Sync()
{
var client = new LookupClient();
var result = client.Query("localhost", QueryType.A);
var answer = result.Answers.OfType <ARecord>().First();
Assert.Equal("127.0.0.1", answer.Address.ToString());
Assert.Equal(QueryClass.IN, result.Questions.First().QuestionClass);
Assert.Equal(QueryType.A, result.Questions.First().QuestionType);
Assert.True(result.Header.AnswerCount > 0);
}
public void Lookup_Defaults()
{
var client = new LookupClient();
Assert.True(client.UseCache);
Assert.False(client.EnableAuditTrail);
Assert.Null(client.MimimumCacheTimeout);
Assert.True(client.Recursion);
Assert.False(client.ThrowDnsErrors);
Assert.Equal(client.Retries, 5);
Assert.Equal(client.Timeout, TimeSpan.FromSeconds(5));
Assert.True(client.UseTcpFallback);
Assert.False(client.UseTcpOnly);
}
static SIPDns()
{
//LookupClientOptions clientOptions = new LookupClientOptions(DnsClient.NameServer.GooglePublicDns)
LookupClientOptions clientOptions = new LookupClientOptions()
{
Retries = DNS_RETRIES_PER_SERVER,
Timeout = TimeSpan.FromSeconds(DNS_TIMEOUT_SECONDS),
UseCache = true,
// TODO: Re-enable when DnsClient adds cache querying.
//UseCacheForFailures = true,
};
_lookupClient = new LookupClient(clientOptions);
}
public LoopupAsyncVsSync()
{
_lookup = new LookupClient(
new LookupClientOptions(IPAddress.Loopback)
{
UseCache = false
});
_lookupNoTtl = new LookupClient(new LookupClientOptions(IPAddress.Loopback)
{
UseCache = false,
Timeout = TimeSpan.FromMilliseconds(Timeout.Infinite)
});
}
static SIPDns()
{
var nameServers = NameServer.ResolveNameServers(skipIPv6SiteLocal: true, fallbackToGooglePublicDns: true);
LookupClientOptions clientOptions = new LookupClientOptions(nameServers.ToArray())
{
Retries = DNS_RETRIES_PER_SERVER,
Timeout = TimeSpan.FromSeconds(DNS_TIMEOUT_SECONDS),
UseCache = true,
CacheFailedResults = true,
FailedResultsCacheDuration = TimeSpan.FromSeconds(CACHE_FAILED_RESULTS_DURATION)
};
_lookupClient = new LookupClient(clientOptions);
}
public void Lookup_GetHostAddresses_LocalReverse_NoResult_Sync()
{
// expecting no result as reverse lookup must be explicit
var client = new LookupClient {
Timeout = TimeSpan.FromMilliseconds(500)
};
client.EnableAuditTrail = true;
var result = client.Query("127.0.0.1", ARecord.ResourceRecordType);
Assert.Equal(QueryClass.In, result.Questions.First().QuestionClass);
Assert.Equal(ARecord.ResourceRecordType, result.Questions.First().QuestionType);
Assert.True(result.Header.AnswerCount == 0);
}
static SIPDns()
{
var nameServers = NameServer.ResolveNameServers(skipIPv6SiteLocal: true, fallbackToGooglePublicDns: true);
LookupClientOptions clientOptions = new LookupClientOptions(nameServers.ToArray())
{
Retries = DNS_RETRIES_PER_SERVER,
Timeout = TimeSpan.FromSeconds(DNS_TIMEOUT_SECONDS),
UseCache = true,
// TODO: Re-enable when DnsClient adds cache querying.
//UseCacheForFailures = true,
};
_lookupClient = new LookupClient(clientOptions);
}
public SharedFunctions(IHttpClientFactory httpClientFactory, LookupClient lookupClient,
IAcmeProtocolClientFactory acmeProtocolClientFactory, IKuduClientFactory kuduClientFactory,
WebSiteManagementClient webSiteManagementClient, DnsManagementClient dnsManagementClient,
WebhookClient webhookClient, IOptions <AcmebotOptions> options)
{
_httpClientFactory = httpClientFactory;
_lookupClient = lookupClient;
_acmeProtocolClientFactory = acmeProtocolClientFactory;
_kuduClientFactory = kuduClientFactory;
_webSiteManagementClient = webSiteManagementClient;
_dnsManagementClient = dnsManagementClient;
_webhookClient = webhookClient;
_options = options.Value;
}
public void LookupClient_SettingsValid()
{
var defaultOptions = new LookupClientOptions();
var options = new LookupClientOptions
{
AutoResolveNameServers = !defaultOptions.AutoResolveNameServers,
ContinueOnDnsError = !defaultOptions.ContinueOnDnsError,
ContinueOnEmptyResponse = !defaultOptions.ContinueOnEmptyResponse,
EnableAuditTrail = !defaultOptions.EnableAuditTrail,
MinimumCacheTimeout = TimeSpan.FromMinutes(1),
MaximumCacheTimeout = TimeSpan.FromMinutes(42),
Recursion = !defaultOptions.Recursion,
Retries = defaultOptions.Retries * 2,
ThrowDnsErrors = !defaultOptions.ThrowDnsErrors,
Timeout = TimeSpan.FromMinutes(10),
UseCache = !defaultOptions.UseCache,
UseRandomNameServer = !defaultOptions.UseRandomNameServer,
UseTcpFallback = !defaultOptions.UseTcpFallback,
UseTcpOnly = !defaultOptions.UseTcpOnly,
ExtendedDnsBufferSize = 1234,
RequestDnsSecRecords = true,
CacheFailedResults = true,
FailedResultsCacheDuration = TimeSpan.FromSeconds(10)
};
var client = new LookupClient(options);
// Not resolving or setting any servers => should be empty.
Assert.Empty(client.NameServers);
Assert.Equal(!defaultOptions.ContinueOnDnsError, client.Settings.ContinueOnDnsError);
Assert.Equal(!defaultOptions.ContinueOnEmptyResponse, client.Settings.ContinueOnEmptyResponse);
Assert.Equal(!defaultOptions.EnableAuditTrail, client.Settings.EnableAuditTrail);
Assert.Equal(TimeSpan.FromMinutes(1), client.Settings.MinimumCacheTimeout);
Assert.Equal(TimeSpan.FromMinutes(42), client.Settings.MaximumCacheTimeout);
Assert.Equal(!defaultOptions.Recursion, client.Settings.Recursion);
Assert.Equal(defaultOptions.Retries * 2, client.Settings.Retries);
Assert.Equal(!defaultOptions.ThrowDnsErrors, client.Settings.ThrowDnsErrors);
Assert.Equal(TimeSpan.FromMinutes(10), client.Settings.Timeout);
Assert.Equal(!defaultOptions.UseCache, client.Settings.UseCache);
Assert.Equal(!defaultOptions.UseRandomNameServer, client.Settings.UseRandomNameServer);
Assert.Equal(!defaultOptions.UseTcpFallback, client.Settings.UseTcpFallback);
Assert.Equal(!defaultOptions.UseTcpOnly, client.Settings.UseTcpOnly);
Assert.Equal(1234, client.Settings.ExtendedDnsBufferSize);
Assert.Equal(!defaultOptions.RequestDnsSecRecords, client.Settings.RequestDnsSecRecords);
Assert.Equal(!defaultOptions.CacheFailedResults, client.Settings.CacheFailedResults);
Assert.Equal(TimeSpan.FromSeconds(10), client.Settings.FailedResultsCacheDuration);
Assert.Equal(new LookupClientSettings(options), client.Settings);
}
public void GetHostEntry_ByIp_NoHost_WithThrow()
{
var client = new LookupClient(
new LookupClientOptions(NameServer.GooglePublicDns)
{
ThrowDnsErrors = true
});
Action act = () => client.GetHostEntry("1.0.0.0");
var ex = Assert.ThrowsAny <DnsResponseException>(() => client.GetHostEntry("1.0.0.0"));
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
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 void GetHostEntry_ByIp_NoHost_WithThrow()
{
var client = new LookupClient()
{
ThrowDnsErrors = true
};
Action act = () => client.GetHostEntry("1.0.0.0");
var ex = Record.Exception(act) as DnsResponseException;
Assert.NotNull(ex);
Assert.Equal(DnsResponseCode.NotExistentDomain, ex.Code);
}
/// <summary>
/// Get the RadioDNS Application
/// </summary>
/// <param name="applicationId">Application Identifier</param>
/// <returns>RadioDNS Application</returns>
private async Task <Application> ResolveApplication(string applicationId)
{
string authoritativeFqdn = GetAuthoritativeFqdn();
string applicationFqdn;
// Check params exist
if (applicationId == null)
{
throw new ArgumentNullException("Application ID not provided.");
}
if (authoritativeFqdn == null)
{
throw new NullReferenceException("Unable to retrive Authoritative FQDN.");
}
applicationFqdn = string.Format("_{0}._tcp.{1}", applicationId.ToLower(), authoritativeFqdn);
// Perform DNS lookup of SRV record(s)
try
{
LookupClient client = new LookupClient();
IDnsQueryResponse response = await client.QueryAsync(applicationFqdn, QueryType.SRV);
if (response.HasError)
{
throw new DnsResponseException(string.Format("Response had an error. {0}", response.ErrorMessage));
}
IReadOnlyList <DnsResourceRecord> records = response.Answers;
if (records.Count > 0)
{
// We have SRV records. Copy them to our records object and return a valid Application.
List <Record> applicationRecords = new List <Record>();
foreach (SrvRecord r in records)
{
applicationRecords.Add(new Record(r));
}
return(new Application(applicationId, applicationRecords));
}
else
{
throw new DnsResponseParseException("Response had no results.");
}
;
}
catch (Exception)
{
return(null);
}
}
private void Initialize(IApplicationEnvironment appEnv)
{
string jsonFile;
#if DEBUG
jsonFile = "Config.local.json";
#else
jsonFile = "Config.json";
#endif
var builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile(jsonFile);
Configuration = builder.Build();
client = new LookupClient(Configuration["Data:ApiKey"], Configuration["Data:ClientName"]);
}
public void Lookup_QueryTimesOut_Tcp_Sync()
{
var client = new LookupClient(
new LookupClientOptions(NameServer.GooglePublicDns)
{
Timeout = s_timeout,
Retries = 0,
UseTcpOnly = true
});
var ex = Assert.ThrowsAny <DnsResponseException>(() => client.Query("lala.com", QueryType.A));
Assert.Equal(DnsResponseCode.ConnectionTimeout, ex.Code);
Assert.Contains("timed out", ex.Message);
}
public async Task Lookup_QueryTimesOut_Udp_Async()
{
var client = new LookupClient(
new LookupClientOptions(NameServer.GooglePublicDns)
{
Timeout = s_timeout,
Retries = 0,
UseTcpFallback = false
});
var ex = await Assert.ThrowsAnyAsync <DnsResponseException>(() => client.QueryAsync("lala.com", QueryType.A));
Assert.Equal(DnsResponseCode.ConnectionTimeout, ex.Code);
Assert.Contains("timed out", ex.Message);
}
public SharedFunctions(IHttpClientFactory httpClientFactory, LookupClient lookupClient,
IAcmeProtocolClientFactory acmeProtocolClientFactory, IOptions <LetsEncryptOptions> options,
KeyVaultClient keyVaultClient, DnsManagementClient dnsManagementClient
, FrontDoorManagementClient frontDoorManagementClient
, ResourceManagementClient resourceManagementClient)
{
_httpClientFactory = httpClientFactory;
_lookupClient = lookupClient;
_acmeProtocolClientFactory = acmeProtocolClientFactory;
_options = options.Value;
_keyVaultClient = keyVaultClient;
_dnsManagementClient = dnsManagementClient;
_frontDoorManagementClient = frontDoorManagementClient;
_resourceManagementClient = resourceManagementClient;
}
private static string[] FindMXRecords(string email_Adress)
{
List <string> mx_Records = new List <string>();
string domain = email_Adress.Substring(email_Adress.IndexOf("@") + 1);
var client = new LookupClient();
var result = client.Query(domain, QueryType.MX);
foreach (DnsClient.Protocol.MxRecord record in result.Answers)
{
mx_Records.Add(record.Exchange.Value);
}
return(mx_Records.ToArray());
}
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}");
}
public async Task Lookup_GetHostAddresses_LocalReverse_NoResult()
{
// expecting no result as reverse lookup must be explicit
var client = new LookupClient()
{
Timeout = TimeSpan.FromMilliseconds(500)
};
client.EnableAuditTrail = true;
var result = await client.QueryAsync("127.0.0.1", QueryType.A);
Assert.Equal(QueryClass.IN, result.Questions.First().QuestionClass);
Assert.Equal(QueryType.A, result.Questions.First().QuestionType);
Assert.True(result.Header.AnswerCount == 0);
}
