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