public TestResponse InvokeNoDefaults(LookupClientOptions lookupClientOptions, DnsQueryAndServerOptions useOptions, IReadOnlyCollection <NameServer> useServers) { var testClient = new TestClient(lookupClientOptions); IDnsQueryResponse response = null; if (ResolverServers != null) { response = ResolverServers(testClient.Client, useServers); } else if (ResolverQueryOptions != null) { response = ResolverQueryOptions(testClient.Client, useOptions); } else if (ResolverServersAndOptions != null) { response = ResolverServersAndOptions(testClient.Client, useOptions, useServers); } else { response = ResolverSimple(testClient.Client); } return(new TestResponse(testClient, response)); }
public void NonRespondingDNSServerTest() { logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name); logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name); var originalClient = SIPDns.LookupClient; try { LookupClientOptions clientOptions = new LookupClientOptions(IPAddress.Loopback) { Retries = 3, Timeout = TimeSpan.FromSeconds(1), UseCache = true, UseTcpFallback = false }; SIPDns.LookupClient = new LookupClient(clientOptions); CancellationTokenSource cts = new CancellationTokenSource(); var result = SIPDns.ResolveAsync(SIPURI.ParseSIPURIRelaxed("sipsorcery.com"), false, cts.Token).Result; Assert.Equal(SIPEndPoint.Empty, result); } finally { SIPDns.LookupClient = originalClient; } }
public static void InitClient(List <string> dnsServers) { if (_client == null) { lock (typeof(DNSUtils)) { if (_client == null) { IPAddress[] nameServers = { }; if (dnsServers?.Count > 0) { nameServers = dnsServers.SelectMany(x => Dns.GetHostAddresses(x)).ToArray(); } var clientOptions = new LookupClientOptions(nameServers) { UseCache = false }; _client = new LookupClient(clientOptions); } } } }
public TestResponse Invoke(LookupClientOptions lookupClientOptions = null, DnsQueryAndServerOptions useOptions = null, IReadOnlyCollection <NameServer> useServers = null) { var testClient = new TestClient(lookupClientOptions); var servers = useServers ?? new NameServer[] { IPAddress.Loopback }; var queryOptions = useOptions ?? new DnsQueryAndServerOptions(); IDnsQueryResponse response = null; if (ResolverServers != null) { response = ResolverServers(testClient.Client, servers); } else if (ResolverQueryOptions != null) { response = ResolverQueryOptions(testClient.Client, queryOptions); } else if (ResolverServersAndOptions != null) { response = ResolverServersAndOptions(testClient.Client, queryOptions, useServers); } else { response = ResolverSimple(testClient.Client); } return(new TestResponse(testClient, response)); }
public void LookupClientOptions_DefaultsNoResolve() { var options = new LookupClientOptions() { AutoResolveNameServers = false }; Assert.Equal(0, options.NameServers.Count); Assert.False(options.AutoResolveNameServers); Assert.True(options.UseCache); Assert.False(options.EnableAuditTrail); Assert.Null(options.MinimumCacheTimeout); Assert.Null(options.MaximumCacheTimeout); Assert.True(options.Recursion); Assert.False(options.ThrowDnsErrors); Assert.Equal(2, options.Retries); Assert.Equal(options.Timeout, TimeSpan.FromSeconds(5)); Assert.True(options.UseTcpFallback); Assert.False(options.UseTcpOnly); Assert.True(options.ContinueOnDnsError); Assert.True(options.ContinueOnEmptyResponse); Assert.True(options.UseRandomNameServer); Assert.Equal(DnsQueryOptions.MaximumBufferSize, options.ExtendedDnsBufferSize); Assert.False(options.RequestDnsSecRecords); }
public void NonRespondingDNSServerTest() { logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name); logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name); var originalClient = SIPDns.LookupClient; try { LookupClientOptions clientOptions = new LookupClientOptions(IPAddress.Loopback) { Retries = 3, Timeout = TimeSpan.FromSeconds(1), UseCache = true, UseTcpFallback = false }; SIPDns.PreferIPv6NameResolution = true; SIPDns.LookupClient = new LookupClient(clientOptions); var result = SIPDns.Resolve(SIPURI.ParseSIPURIRelaxed("sipsorcery.com"), false).Result; Assert.Null(result); } finally { SIPDns.LookupClient = originalClient; SIPDns.PreferIPv6NameResolution = false; } }
public void LookupClientOptions_InvalidMinimumCacheTimeout1() { var options = new LookupClientOptions(); Action act = () => options.MinimumCacheTimeout = TimeSpan.FromMilliseconds(-23); Assert.ThrowsAny <ArgumentOutOfRangeException>(act); }
public void LookupClientOptions_MaximumCacheTimeout_ZeroIgnored() { var options = new LookupClientOptions(); options.MaximumCacheTimeout = TimeSpan.Zero; Assert.Null(options.MaximumCacheTimeout); }
public void LookupClientOptions_InvalidCacheFailureDuration3() { var options = new LookupClientOptions(); Action act = () => options.FailedResultsCacheDuration = TimeSpan.FromDays(25); Assert.ThrowsAny <ArgumentOutOfRangeException>(act); }
public void LookupClientOptions_MaximumCacheTimeout_AcceptsInfinite() { var options = new LookupClientOptions(); options.MaximumCacheTimeout = Timeout.InfiniteTimeSpan; Assert.Equal(Timeout.InfiniteTimeSpan, options.MaximumCacheTimeout); }
public void LookupClientOptions_InvalidMaximumCacheTimeout2() { var options = new LookupClientOptions(); Action act = () => options.MaximumCacheTimeout = TimeSpan.FromDays(25); Assert.ThrowsAny <ArgumentOutOfRangeException>(act); }
public void ResolveAsync(List <string> hosts) { Task.Run(() => { // Foreach host foreach (var host in hosts) { var query = host; // Append dns suffix to hostname if (QueryType != QueryType.PTR && AddDNSSuffix && query.IndexOf(".", StringComparison.OrdinalIgnoreCase) == -1) { var dnsSuffix = UseCustomDNSSuffix ? CustomDNSSuffix : IPGlobalProperties.GetIPGlobalProperties().DomainName; if (!string.IsNullOrEmpty(dnsSuffix)) { query += $".{dnsSuffix}"; } } // Foreach dns server Parallel.ForEach(GetDnsServer(), dnsServer => { LookupClientOptions lookupClientOptions = new LookupClientOptions { UseTcpOnly = UseTCPOnly, UseCache = UseCache, Recursion = Recursion, Timeout = Timeout, Retries = Retries, }; LookupClient dnsLookupClient = new LookupClient(lookupClientOptions); try { // PTR vs A, AAAA, CNAME etc. var dnsResponse = QueryType == QueryType.PTR ? dnsLookupClient.QueryReverse(IPAddress.Parse(query)) : dnsLookupClient.Query(query, QueryType, QueryClass); // If there was an error... return if (dnsResponse.HasError) { OnLookupError(new DNSLookupErrorArgs(dnsResponse.ErrorMessage, new IPEndPoint(IPAddress.Parse(dnsResponse.NameServer.Address), dnsResponse.NameServer.Port))); return; } // Process the results... ProcessDnsQueryResponse(dnsResponse); } catch (Exception ex) { OnLookupError(new DNSLookupErrorArgs(ex.Message, dnsServer)); } }); } OnLookupComplete(); }); }
public void LookupClientOptions_MaximumCacheTimeout_AcceptsNull() { var options = new LookupClientOptions() { MaximumCacheTimeout = Timeout.InfiniteTimeSpan }; options.MaximumCacheTimeout = null; Assert.Null(options.MaximumCacheTimeout); }
static STUNDns() { LookupClientOptions clientOptions = new LookupClientOptions() { Retries = DNS_RETRIES_PER_SERVER, Timeout = TimeSpan.FromSeconds(DNS_TIMEOUT_SECONDS), UseCache = true, UseTcpFallback = false }; _lookupClient = new LookupClient(clientOptions); }
private async Task <IDnsQueryResponse> QueryDnsServer(DnsServer server, string url, QueryType queryType, TimeSpan timeout, int retries = 0) { LookupClientOptions options = new LookupClientOptions(new IPAddress[] { server.IPAddress }) { Timeout = timeout, Retries = retries, }; var client = new LookupClient(options); return(await client.QueryAsync(url, queryType)); }
static SIPDns() { 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); }
//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); }
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 LookupClientSettings_Equal(LookupClientOptions options) { var opt = new LookupClientSettings(options); var opt2 = new LookupClientSettings(options); Assert.StrictEqual(opt, opt2); // typed overload Assert.True(opt.Equals(opt2)); // object overload Assert.True(opt.Equals((object)opt2)); }
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); }
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 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 LookupClientSettings_NotEqual(LookupClientOptions otherOptions) { var opt = new LookupClientSettings(new LookupClientOptions() { AutoResolveNameServers = false }); var opt2 = new LookupClientSettings(otherOptions); Assert.NotStrictEqual(opt, opt2); // typed overload Assert.False(opt.Equals(opt2)); // object overload Assert.False(opt.Equals((object)opt2)); }
private static void Main(string[] args) { var port = 5053; var server = new StaticDnsServer( printStats: false, port: port, workers: 2); server.Start(); var options = new LookupClientOptions(new NameServer(IPAddress.Parse("127.0.0.1"), port)) { UseCache = false, EnableAuditTrail = false, UseTcpFallback = false, ThrowDnsErrors = false, MinimumCacheTimeout = null, Retries = 0, Timeout = Timeout.InfiniteTimeSpan }; var client = new LookupClient(options); var tasksCount = 12; //Console.WriteLine("warmup"); //RunSync(client, 5, tasksCount); //RunAsync(client, 5, tasksCount).Wait(); Console.WriteLine("running..."); Console.ReadKey(); double runTime = 2; for (var i = 1; i <= 3; i++) { for (var run = 0; run < 5; run++) { RunSync(client, runTime, tasksCount * i); RunAsync(client, runTime, tasksCount * i).GetAwaiter().GetResult(); } } server.Stop(); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var user = (User)validationContext.ObjectInstance; string email = user.Email; if (email == null) { return(new ValidationResult("Email is null")); } Regex rx = new Regex(@"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}", RegexOptions.IgnoreCase); MatchCollection matches = rx.Matches(email); if (matches.Count == 0) { return(new ValidationResult("Email is incorrect!")); } var context = (DatabaseCtx)validationContext.GetService(typeof(DatabaseCtx)); var entity = context.Users.SingleOrDefault(e => e.Email == email); if (entity != null) { return(new ValidationResult("Email is already in use")); } var options = new LookupClientOptions(); options.Timeout = TimeSpan.FromSeconds(5); var lookup = new LookupClient(options); var result = lookup.Query(email.Split('@')[1], QueryType.MX); var records = result.Answers; if (!records.Any()) { return(new ValidationResult("Email does not exist")); } return(ValidationResult.Success); }
public DnsClientLibBasedDnsResolver(DnsResolverSettings?settings = null) : base(settings) { try { LookupClientOptions opt; if (Settings.DnsServersList.Any()) { opt = new LookupClientOptions(Settings.DnsServersList.ToArray()); } else { opt = new LookupClientOptions(); } var flags = Settings.Flags; opt.AutoResolveNameServers = flags.Bit(DnsResolverFlags.UseSystemDnsClientSettings); opt.UseTcpOnly = flags.Bit(DnsResolverFlags.TcpOnly); opt.UseTcpFallback = !flags.Bit(DnsResolverFlags.UdpOnly); opt.UseRandomNameServer = flags.Bit(DnsResolverFlags.RoundRobinServers); opt.UseCache = !flags.Bit(DnsResolverFlags.DisableCache); opt.ThrowDnsErrors = flags.Bit(DnsResolverFlags.ThrowDnsError); opt.Recursion = !flags.Bit(DnsResolverFlags.DisableRecursion); opt.Timeout = Settings.TimeoutOneQuery._ToTimeSpanMSecs(); opt.Retries = Math.Max(Settings.NumTry, 1) - 1; opt.MinimumCacheTimeout = Settings.MinCacheTimeout._ToTimeSpanMSecs(); opt.MaximumCacheTimeout = Settings.MaxCacheTimeout._ToTimeSpanMSecs(); this.Client = new LookupClient(opt); } catch { this._DisposeSafe(); throw; } }
private static async Task <bool> CheckDnsEntriesAsync(string domain) { try { LookupClientOptions options = new LookupClientOptions { Timeout = TimeSpan.FromSeconds(5) }; var lookup = new LookupClient(options); //Performs a DNS lookup for the given question. var result = await lookup.QueryAsync(domain, QueryType.ANY).ConfigureAwait(false); var records = result.Answers.Where(record => record.RecordType == DnsClient.Protocol.ResourceRecordType.A || record.RecordType == DnsClient.Protocol.ResourceRecordType.AAAA || record.RecordType == DnsClient.Protocol.ResourceRecordType.MX); return(records.Any()); } catch (DnsResponseException) { return(false); } }
private static IServiceCollection RegisterDnsLookup(this IServiceCollection services) { //implement the dns lookup and register to service container services.TryAddSingleton <IDnsQuery>(p => { var serviceConfiguration = p.GetRequiredService <IOptions <ConsulServiceDiscoveryOption> >().Value; var iPEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8600); if (serviceConfiguration.Consul.DnsEndpoint != null) { iPEndPoint = serviceConfiguration.Consul.DnsEndpoint.ToIPEndPoint(); } var options = new LookupClientOptions(iPEndPoint) { EnableAuditTrail = false, MinimumCacheTimeout = TimeSpan.FromSeconds(1), UseCache = true }; var client = new LookupClient(options); return(client); }); return(services); }
public DnsResolveCommand( string commandSource, IUser user, IList <string> arguments, ILogger logger, IFlagService flagService, IConfigurationProvider configurationProvider, IIrcClient client, IResponder responder) : base( commandSource, user, arguments, logger, flagService, configurationProvider, client) { this.responder = responder; var options = new LookupClientOptions { UseCache = false, EnableAuditTrail = true }; this.dnsClient = new LookupClient(options); }
protected override async Task <int> Execute() { _clients = ClientsArg.HasValue() ? int.Parse(ClientsArg.Value()) : 10; if (_clients <= 0) { throw new ArgumentOutOfRangeException(nameof(ClientsArg)); } _tasks = TasksArg.HasValue() ? int.Parse(TasksArg.Value()) : 8; if (_clients <= 0) { throw new ArgumentOutOfRangeException(nameof(TasksArg)); } _runtime = RuntimeArg.HasValue() ? int.Parse(RuntimeArg.Value()) <= 1 ? 5 : int.Parse(RuntimeArg.Value()) : 5; _query = string.IsNullOrWhiteSpace(QueryArg.Value) ? string.Empty : QueryArg.Value; _runSync = SyncArg.HasValue(); _settings = GetLookupSettings(); _settings.EnableAuditTrail = false; _lookup = GetDnsLookup(_settings); _running = true; Console.WriteLine($"; <<>> Starting perf run with {_clients} (x{_tasks}) clients running for {_runtime} seconds <<>>"); Console.WriteLine($"; ({_settings.NameServers.Count} Servers, caching:{_settings.UseCache}, minttl:{_settings.MinimumCacheTimeout?.TotalMilliseconds}, maxttl:{_settings.MaximumCacheTimeout?.TotalMilliseconds})"); _spinner = new Spiner(); _spinner.Start(); var sw = Stopwatch.StartNew(); var timeoutTask = Task.Delay(_runtime * 1000).ContinueWith((t) => { _running = false; }); var tasks = new List <Task> { timeoutTask }; for (var clientIndex = 0; clientIndex < _clients; clientIndex++) { tasks.Add(ExcecuteRun(numTasks: _tasks)); } tasks.Add(CollectPrint()); await Task.WhenAny(tasks.ToArray()); double elapsedSeconds = sw.ElapsedMilliseconds / 1000d; // results _spinner.Stop(); Console.WriteLine(string.Join("-", Enumerable.Repeat("-", 50))); Console.WriteLine($";; results:\t\t"); Console.WriteLine(string.Join("-", Enumerable.Repeat("-", 50))); Console.WriteLine($";; run for {elapsedSeconds}sec {_clients} (x{_tasks}) clients."); var successPercent = _errors == 0 ? 100 : _success == 0 ? 0 : (100 - ((double)_errors / (_success) * 100)); Console.WriteLine($";; {_errors:N0} errors {_success:N0} ok {successPercent:N2}% success."); var execPerSec = _allExcecutions / elapsedSeconds; Console.WriteLine($";; {execPerSec:N2} queries per second."); return(0); }