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