public void DnsResolve(string[] args) { string domain = args.GetRequiredValue(0); DnsStandard.RecordType recordType = args.GetOptionalEnum <DnsStandard.RecordType>(1, DnsStandard.RecordType.ANAME); try { using (DnsClient client = CreateClient()) { client.UseUDPFirst = (recordType != DnsStandard.RecordType.CERT); DnsResponse response = client.Resolve(new DnsRequest(recordType, domain)); if (response == null) { Console.WriteLine("No matches"); return; } m_recordPrinter.Print(response); } } catch (DnsServerException ex) { Console.WriteLine(ex.ResponseCode); } }
DnsResponse CreateResponse(DnsRequest request, IEnumerable <DnsResourceRecord> matches) { DnsStandard.RecordType questionType = request.Question.Type; DnsResponse response = new DnsResponse(request); int matchCount = 0; foreach (DnsResourceRecord record in matches) { if (record.Type == questionType) { ++matchCount; switch (record.Type) { default: response.AnswerRecords.Add(record); break; case DnsStandard.RecordType.NS: case DnsStandard.RecordType.SOA: response.AnswerRecords.Add(record); break; } } } if (matchCount == 0) { throw new DnsServerException(DnsStandard.ResponseCode.NameError); } return(response); }
public TestThread(DnsStandard.RecordType type, bool udp, TestServer server, TimeSpan timeout) { m_server = server; m_udp = udp; m_type = type; m_timeout = timeout; }
void TestType <T>(DnsStandard.RecordType recordType, string domain, Func <T, bool> verify) where T : DnsResourceRecord { bool threw = false; try { using (Socket socket = TestServer.Default.CreateTCPSocket()) { TestTCPClient client = new TestTCPClient(socket); DnsRequest request = new DnsRequest(recordType, domain); client.Send(request); DnsResourceRecord record = client.Receive(); Assert.True(record.Type == recordType); Assert.True(record.Name.Equals(request.Question.Domain, StringComparison.OrdinalIgnoreCase)); T rr = null; Assert.Null(Record.Exception(() => rr = (T)record)); Assert.True(verify(rr)); } } catch { threw = true; } Assert.False(threw); }
internal int GetMinTTL(DnsStandard.RecordType recordType) { int minTTL = int.MaxValue; // overall min ttl int minTTLType = int.MaxValue; // min ttl for the given record type foreach (DnsResourceRecord record in this.AllRecords) { int newTTL = record.TTL; if (recordType == record.Type) { if (newTTL < minTTLType) { minTTLType = newTTL; } } if (newTTL < minTTL) { minTTL = newTTL; } } if (minTTLType == int.MaxValue) { minTTLType = minTTL; } return((minTTLType == int.MaxValue || minTTLType < 0) ? 0 : minTTLType); }
internal void Deserialize(ref DnsBufferReader reader) { this.Name = reader.ReadDomainName(); this.Type = (DnsStandard.RecordType)reader.ReadShort(); this.Class = (DnsStandard.Class)reader.ReadShort(); this.TTL = reader.ReadInt(); this.RecordDataLength = reader.ReadShort(); }
public void TestNotSupported(string domain, DnsStandard.RecordType type, bool useUDP) { DnsClient client = TestServer.Default.CreateClient(); client.UseUDPFirst = !useUDP; DnsResponse response = client.Resolve(new DnsRequest(type, domain)); Assert.True(!response.IsSuccess); }
DnsRecord[] GetRecords(string domain, DnsStandard.RecordType type) { DnsRecord[] records = Client.GetMatchingDnsRecordsByType(domain, type); if (records.IsNullOrEmpty()) { throw new ArgumentException("No matches"); } return(records); }
void Match(string domain, DnsStandard.RecordType type) { DnsRecord[] records = this.GetRecords(domain, type); if (records.IsNullOrEmpty()) { throw new ArgumentException("No matches"); } Print(records); }
public DnsRecord[] EnumerateDnsRecordsByType(long lastID, int maxResults, DnsStandard.RecordType type) { try { return(Store.DnsRecords.Get(lastID, maxResults, type)); } catch (Exception ex) { throw CreateFault("EnumerateDnsRecordsByType", ex); } }
public void ResolveWithNameErrors(string domain, DnsStandard.RecordType type) { using (DnsClient client = s_authoritativeResolverServer.CreateClient()) { DnsResponse response = client.Resolve(new DnsRequest(new DnsQuestion(domain, type))); Assert.False(response.HasAdditionalRecords); Assert.False(response.HasAnswerRecords); Assert.False(response.HasAnyRecords); Assert.True(response.IsNameError); } }
/// <summary> /// Factory for DnsResourceRecord objects /// </summary> /// <param name="recordType"></param> /// <returns></returns> public static DnsResourceRecord CreateRecordObject(DnsStandard.RecordType recordType) { DnsResourceRecord record; switch (recordType) { default: record = new RawRecord(); break; case DnsStandard.RecordType.ANAME: record = new AddressRecord(); break; case DnsStandard.RecordType.NS: record = new NSRecord(); break; case DnsStandard.RecordType.CNAME: record = new CNameRecord(); break; case DnsStandard.RecordType.SOA: record = new SOARecord(); break; case DnsStandard.RecordType.TXT: record = new TextRecord(); break; case DnsStandard.RecordType.MX: record = new MXRecord(); break; case DnsStandard.RecordType.PTR: record = new PtrRecord(); break; case DnsStandard.RecordType.CERT: record = new CertRecord(); break; case DnsStandard.RecordType.SRV: record = new SRVRecord(); break; } return(record); }
/// <summary> /// Provides an enumeration of records of the specified type. /// </summary> /// <typeparam name="T">The RR type</typeparam> /// <param name="type">The RR type to enumerate</param> /// <returns>The enumeration of RRs of the specified type.</returns> public IEnumerable <T> Enumerate <T>(DnsStandard.RecordType type) where T : DnsResourceRecord { foreach (DnsResourceRecord record in this) { if (record.Type == type) { T typedRecord = record as T; if (typedRecord != null) { yield return(typedRecord); } } } }
public IEnumerable <DnsResourceRecord> this[string domainName, DnsStandard.RecordType type] { get { IEnumerable <DnsResourceRecord> matches = this[domainName]; if (matches == null) { return(null); } return( from record in matches where record.Type == type select record ); } }
DnsResponse ProcessRequest(DnsRequest request) { DnsStandard.RecordType questionType = request.Question.Type; DnsResponse response = new DnsResponse(request); response.Header.IsAuthoritativeAnswer = true; switch (response.Question.Type) { default: throw new DnsServerException(DnsStandard.ResponseCode.NotImplemented); case DnsStandard.RecordType.ANAME: ProcessANAMEQuestion(response); break; case DnsStandard.RecordType.NS: ProcessNSQuestion(response); break; case DnsStandard.RecordType.MX: ProcessMXQuestion(response); break; case DnsStandard.RecordType.SOA: ProcessSOAQuestion(response); break; case DnsStandard.RecordType.CERT: ProcessCERTQuestion(response); break; case DnsStandard.RecordType.CNAME: ProcessCNAMEQuestion(response); break; case DnsStandard.RecordType.SRV: ProcessSRVQuestion(response); break; } return(response); }
public void ResolveSuccess(string domain, DnsStandard.RecordType type) { using (DnsClient client = s_authoritativeResolverServer.CreateClient()) { switch (type) { case DnsStandard.RecordType.ANAME: ResolveA(client, domain); break; case DnsStandard.RecordType.MX: ResolveMX(client, domain); break; case DnsStandard.RecordType.CERT: ResolveCert(client, domain); break; default: throw new NotSupportedException(); } } }
/// <summary> /// Initializes a query for domain /// </summary> /// <param name="qType">The record type to query</param> /// <param name="domain">The domain to query.</param> public DnsRequest(DnsStandard.RecordType qType, string domain) : this(new DnsQuestion(domain, qType)) { }
public static void GetMatches(this RecordRetrievalServiceClient client, string domain, DnsResourceRecordCollection resourceRecords, DnsStandard.RecordType recordType) { DnsRecord[] matches = client.GetMatchingDnsRecords(domain, recordType); if (matches.IsNullOrEmpty()) { return; } foreach (DnsRecord record in matches) { DnsResourceRecord responseRecord = record.Deserialize(); if (responseRecord != null && responseRecord.Type == recordType) { resourceRecords.Add(responseRecord); } } }
/// <summary> /// Gets and sets the raw data for this RR /// Not all DNS Record are mapped to a custom object by this library. /// Dns Records not specifically parsed are turned into RawRecord objects /// </summary> /// <param name="name"></param> /// <param name="type"></param> /// <param name="record"></param> public RawRecord(string name, DnsStandard.RecordType type, byte[] record) : base(name, type) { this.RecordBytes = record; }
internal void Deserialize(ref DnsBufferReader reader) { this.Name = reader.ReadDomainName(); this.Type = (DnsStandard.RecordType) reader.ReadShort(); this.Class = (DnsStandard.Class) reader.ReadShort(); this.TTL = reader.ReadInt(); this.RecordDataLength = reader.ReadShort(); }
public DnsRecord[] GetMatchingDnsRecordsByType(string domainName , DnsStandard.RecordType typeID) { return(Store.DnsRecords.Get(domainName , typeID)); }
public DnsRecord[] GetLastDnsRecords(long lastRecordID, int maxResults, DnsStandard.RecordType typeID) { return(Store.DnsRecords.Get(lastRecordID , maxResults , typeID)); }
public TestThread(DnsStandard.RecordType type, bool udp) : this(type, udp, TestServer.Default) { }
/// <summary> /// Initializes an instance for the specified domain and type /// </summary> /// <param name="domain">The domain we are querying.</param> /// <param name="type">The record type we are querying.</param> public DnsQuestion(string domain, DnsStandard.RecordType type) : this(domain, type, DnsStandard.Class.IN) { }
/// <summary> /// Instantiates a Dns Message /// </summary> /// <param name="qType"></param> /// <param name="qName"></param> protected DnsMessage(DnsStandard.RecordType qType, string qName) : this(new DnsQuestion(qName, qType, DnsStandard.Class.IN)) { }
public DnsRecord(string domainName, DnsStandard.RecordType recordType, byte[] recordData, string notes) : this(domainName, (int)recordType, recordData, notes) { }
public TestThread(DnsStandard.RecordType type, bool udp, TestServer server) : this(type, udp, server, TimeSpan.FromMilliseconds(1000)) { }
/// <summary> /// Initializes an instance for the specified domain and type /// </summary> /// <param name="domain">The domain we are querying.</param> /// <param name="type">The record type we are querying.</param> /// <param name="qClass">Use to define a non Internet DNS query</param> public DnsQuestion(string domain, DnsStandard.RecordType type, DnsStandard.Class qClass) { this.Domain = domain; this.Type = type; this.Class = qClass; }
/// <summary> /// Instantiates a new Dns Resource Record /// </summary> /// <param name="name">the domain name for which this is a record</param> /// <param name="type">the record type</param> protected DnsResourceRecord(string name, DnsStandard.RecordType type) { this.Name = name; this.Type = type; this.Class = DnsStandard.Class.IN; }