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