public DnsResponse Get(DnsRequest request)
{
ushort requestID = request.RequestID;
DnsResponse response = null;
try
{
using (DnsClient client = new DnsClient(m_serverIP))
{
if (m_timeout != null)
{
client.Timeout = m_timeout.Value;
}
response = client.Resolve(request);
}
}
finally
{
if (response != null)
{
response.RequestID = requestID;
}
request.RequestID = requestID;
}
return response;
}
/// <summary>
/// Initializes a new instance of the <b>DnsClientWithCacheFacts</b> class.
/// </summary>
public DnsClientWithCacheFacts()
: base(DumpIsEnabled)
{
m_cache = new DnsResponseCache(Guid.NewGuid().ToString("D"));
m_client = new DnsClientWithCache(PublicDns) { Timeout = TimeSpan.FromSeconds(5), Cache = m_cache};
m_client.MaxRetries = 1;
m_clientNoCache = new DnsClient(PublicDns) { Timeout = TimeSpan.FromSeconds(5) };
m_clientNoCache.MaxRetries = 1;
}
X509Certificate2Collection ResolveExtendedDomain(DnsClient client, string name)
{
name = name.Replace('@', '.');
string extendedName = m_fallbackDomain.ConstructEmailDnsDomainName(name);
return this.ResolveDomain(client, extendedName);
}
X509Certificate2Collection ResolveDomain(DnsClient client, string name)
{
name = name.Replace('@', '.');
try
{
IEnumerable<CertRecord> records = null;
if (m_useRootForCertResolve)
{
records = client.ResolveCERTFromNameServer(name);
}
else
{
records = client.ResolveCERT(name);
}
if (records != null)
{
return CollectCerts(null, records);
}
}
catch (DnsServerException dnsEx)
{
if (dnsEx.ResponseCode != DnsStandard.ResponseCode.Refused)
{
throw;
}
}
catch (Exception ex)
{
this.Error.NotifyEvent(this, ex);
throw;
}
return null;
}
X509Certificate2Collection GetCertificates(DnsClient client, string domain)
{
X509Certificate2Collection certs = this.ResolveDomain(client, domain);
if (certs.IsNullOrEmpty() && this.HasFallbackDomain)
{
certs = this.ResolveExtendedDomain(client, domain);
}
return certs;
}
X509Certificate2Collection GetCertificates(DnsClient client, string domain)
{
X509Certificate2Collection certs = ResolveDomain(client, domain);
X509Certificate2Collection validCerts = Validator.FilterValidCerts(certs, m_policy, ProblemFlags, NotifyException);
if (validCerts.IsNullOrEmpty() && HasFallbackDomain)
{
certs = ResolveExtendedDomain(client, domain);
validCerts = Validator.FilterValidCerts(certs, m_policy, ProblemFlags, NotifyException);
}
return validCerts;
}
public DnsResponseToBinExample(){
m_client = new DnsClient(PublicDns) {Timeout = TimeSpan.FromSeconds(10) };
}
/// <summary>
/// Resolves CERT records for <paramref name="domain"/> from the authoritative
/// nameservers for the domain.
/// </summary>
/// <remarks>
/// This method may be used if the typical nameserver used does not handle CERT records.
/// </remarks>
/// <param name="domain">The domain for which to retrieve CERT records.</param>
/// <param name="nameserver">The nameserver from which to retrieve authoratative nameservers
/// for the domain.</param>
/// <returns>An enumeration of <see cref="CertRecord"/> instances.</returns>
public virtual IEnumerable<CertRecord> ResolveCERTFromNameServer(string domain, IPAddress nameserver)
{
if (string.IsNullOrEmpty(domain))
{
throw new ArgumentException("value was null or empty", "domain");
}
if (nameserver == null)
{
throw new ArgumentNullException("nameserver");
}
using (DnsClient client = new DnsClient(nameserver))
{
client.UseUDPFirst = false;
return client.ResolveCERT(domain);
}
}
private IEnumerable<IPAddress> GetNameServers(string domain)
{
IEnumerable<IPAddress> nameServers = null;
foreach (IPEndPoint endpoint in m_primaryDnsServers)
{
DnsClient client = null;
try
{
if (m_doCache)
{
client = new DnsClientWithCache(endpoint);
}
else
{
client = new DnsClient(endpoint);
}
client.Timeout = Timeout;
nameServers = client.GetNameServers(domain);
if (nameServers == null)
{
continue;
}
foreach (IPAddress nameServer in nameServers)
{
if (nameServer != IPAddress.None)
{
return nameServers;
}
}
}
finally
{
if (client != null)
{
client.Dispose();
}
}
}
return null;
}
DnsResponse ProcessRequest(DnsRequest request)
{
IEnumerable<IPAddress> nameServers = GetNameServers(request.Question.Domain);
if (nameServers == null)
{
throw new DnsServerException(DnsStandard.ResponseCode.NameError);
}
bool useUdp = request.Question.Type == DnsStandard.RecordType.CERT ? false : true;
int count = 0;
DnsResponse response = null;
foreach (IPAddress nameserver in nameServers)
{
DnsClient client = null;
try
{
if (m_doCache)
{
client = new DnsClientWithCache(new IPEndPoint(nameserver, m_dnsResolutionPort));
}
else
{
client = new DnsClient(new IPEndPoint(nameserver, m_dnsResolutionPort));
}
client.Timeout = Timeout;
client.UseUDPFirst = useUdp;
DnsRequest newRequest = new DnsRequest(new DnsQuestion(request.Question));
response = client.Resolve(newRequest);
if (response != null)
{
// Clone the response before returning it since the response may be cached
// and we don't want the cached response to be modified.
response = response.Clone();
// updates the TTL of records to reflect the elapsed time since the
// record was cached.
response.UpdateRecordsTTL();
break;
}
}
catch (DnsException)
{
continue;
}
finally
{
if (client != null)
{
client.Dispose();
}
}
count++;
if (count > m_maxNameServersToAttempt)
{
break;
}
}
if (response == null)
{
throw new DnsServerException(DnsStandard.ResponseCode.ServerFailure);
}
response.RequestID = request.RequestID;
return response;
}
static IEnumerable<SRVRecord> RequestSrv(DnsClient client, string domain)
{
var dnsRequest = new DnsRequest(DnsStandard.RecordType.SRV, domain);
var response = client.Resolve(dnsRequest);
if (response == null || !response.HasAnswerRecords)
{
return null;
}
return response.AnswerRecords.SRV
.OrderBy(r => r.Priority)
.OrderByDescending(r => r.Weight);
}
const string PublicDns = "8.8.8.8"; // Google
//const string PublicDns = "151.197.0.38"; // Verizon
//const string PublicDns = "4.2.2.1"; // Level 3
//const string PublicDns = "64.81.111.2"; // Speakeasy
//const string SubnetDns = "192.168.0.1";
//const string LocalDns = "127.0.0.1";
public BasicResolverTests()
{
m_client = new DnsClient(PublicDns) { Timeout = TimeSpan.FromSeconds(10) };
}
private void ResolveCert(DnsClient client, string domain)
{
IEnumerable<DnsResourceRecord> expectedMatches = s_recordTable[domain, DnsStandard.RecordType.CERT];
client.UseUDPFirst = false;
IEnumerable<CertRecord> matches = client.ResolveCERT(domain);
Assert.True(Equals(matches, expectedMatches));
}
private void ResolveMX(DnsClient client, string domain)
{
IEnumerable<DnsResourceRecord> expectedMatches = s_recordTable[domain, DnsStandard.RecordType.MX];
IEnumerable<MXRecord> matches = client.ResolveMX(domain);
Assert.True(Equals(matches, expectedMatches));
}
public DnsClient CreateClient()
{
DnsServerSettings settings = this.Server.Settings;
DnsClient client = new DnsClient(settings.Address, settings.Port);
return client;
}
