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