/// <summary>
/// Compares a Raw Record to this given resource record
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
RawRecord rawRecord = record as RawRecord;
if (rawRecord == null)
{
return false;
}
if (rawRecord.m_bytes.Length != m_bytes.Length)
{
return false;
}
for (int i = 0; i < m_bytes.Length; ++i)
{
if (m_bytes[i] != rawRecord.m_bytes[i])
{
return false;
}
}
return true;
}
public DnsResponse(DnsResponseCode responseCode, DnsRecordType queryType, string queryName, DnsResourceRecord[] answerRecords, DnsResourceRecord[] authorityRecords, DnsResourceRecord[] additionalInformationRecords)
{
this.ResponseCode = responseCode;
this.QueryType = queryType;
this.QueryName = queryName;
this.AnswerRecords = answerRecords;
this.AuthorityRecords = authorityRecords;
this.AdditionalInformationRecords = additionalInformationRecords;
}
/// <summary>
/// Tests equality between this CName record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
CNameRecord cnameRecord = record as CNameRecord;
if (cnameRecord == null)
{
return false;
}
return (DnsStandard.Equals(m_name, cnameRecord.CName));
}
/// <summary>
/// Tests equality between this PTR record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
PtrRecord ptrRecord = record as PtrRecord;
if (ptrRecord == null)
{
return false;
}
return (DnsStandard.Equals(this.m_domain, ptrRecord.m_domain));
}
/// <summary>
/// Helper method to extract the appropriate IP address from a DNS lookup result.
/// The query may have returned an AAAA or A record. This method checks which
/// and extracts the IP address accordingly.
/// </summary>
/// <param name="addrRecord">The DNS lookup result.</param>
/// <param name="port">The port for the IP end point.</param>
/// <returns>An IP end point or null.</returns>
private static IPEndPoint GetFromLookupResult(DnsResourceRecord addrRecord, int port)
{
if (addrRecord is AaaaRecord)
{
return(new IPEndPoint((addrRecord as AaaaRecord).Address, port));
}
else if (addrRecord is ARecord)
{
return(new IPEndPoint((addrRecord as ARecord).Address, port));
}
else
{
return(null);
}
}
/// <summary>
/// Helper method to extract the appropriate IP address from a DNS lookup result.
/// The query may have returned an AAAA or A record. This method checks which
/// and extracts the IP address accordingly.
/// </summary>
/// <param name="addrRecord">The DNS lookup result.</param>
/// <param name="port">The port for the IP end point.</param>
/// <returns>An IP end point or null.</returns>
private static SIPEndPoint GetFromLookupResult(SIPProtocolsEnum protocol, DnsResourceRecord addrRecord, int port)
{
if (addrRecord is AaaaRecord)
{
return(new SIPEndPoint(protocol, (addrRecord as AaaaRecord).Address, port));
}
else if (addrRecord is ARecord)
{
return(new SIPEndPoint(protocol, (addrRecord as ARecord).Address, port));
}
else
{
return(null);
}
}
/// <summary>
/// Tests equality between this NS record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
NSRecord nsRecord = record as NSRecord;
if (nsRecord == null)
{
return false;
}
return (DnsStandard.Equals(m_nameserver, nsRecord.NameServer));
}
public override void UpdateRecord(DnsResourceRecord oldRecord, DnsResourceRecord newRecord)
{
switch (oldRecord.Type)
{
case DnsResourceRecordType.SOA:
throw new InvalidOperationException("Cannot update record: use SetRecords() for " + oldRecord.Type.ToString() + " record");
case DnsResourceRecordType.DNSKEY:
case DnsResourceRecordType.RRSIG:
case DnsResourceRecordType.NSEC:
case DnsResourceRecordType.NSEC3PARAM:
case DnsResourceRecordType.NSEC3:
throw new InvalidOperationException("Cannot update DNSSEC records.");
default:
if (oldRecord.Type != newRecord.Type)
{
throw new InvalidOperationException("Old and new record types do not match.");
}
if ((_primaryZone.DnssecStatus != AuthZoneDnssecStatus.Unsigned) && newRecord.IsDisabled())
{
throw new DnsServerException("Cannot update record: disabling records in a signed zones is not supported.");
}
if (newRecord.OriginalTtlValue > _primaryZone.GetZoneSoaExpire())
{
throw new DnsServerException("Failed to update record: TTL cannot be greater than SOA EXPIRE.");
}
if (!TryDeleteRecord(oldRecord.Type, oldRecord.RDATA, out DnsResourceRecord deletedRecord))
{
throw new InvalidOperationException("Cannot update record: the record does not exists to be updated.");
}
base.AddRecord(newRecord);
_primaryZone.CommitAndIncrementSerial(new DnsResourceRecord[] { deletedRecord }, new DnsResourceRecord[] { newRecord });
if (_primaryZone.DnssecStatus != AuthZoneDnssecStatus.Unsigned)
{
_primaryZone.UpdateDnssecRecordsFor(this, oldRecord.Type);
}
_primaryZone.TriggerNotify();
break;
}
}
public DnsDatagram Query(DnsDatagram request)
{
List <Uri> blockLists = IsZoneBlocked(request.Question[0].Name.ToLower());
if (blockLists == null)
{
return(null); //zone not blocked
}
//zone is blocked
if (_dnsServer.UseNxDomainForBlocking && (request.Question[0].Type != DnsResourceRecordType.TXT))
{
return(new DnsDatagram(request.Identifier, true, DnsOpcode.StandardQuery, false, false, request.RecursionDesired, true, false, false, DnsResponseCode.NxDomain, request.Question));
}
DnsResourceRecord[] answers = null;
DnsResourceRecord[] authority = null;
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.A, request.Question[0].Class, 60, _aRecord) };
break;
case DnsResourceRecordType.AAAA:
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.AAAA, request.Question[0].Class, 60, _aaaaRecord) };
break;
case DnsResourceRecordType.NS:
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.NS, request.Question[0].Class, 60, _nsRecord) };
break;
case DnsResourceRecordType.TXT:
answers = new DnsResourceRecord[blockLists.Count];
for (int i = 0; i < answers.Length; i++)
{
answers[i] = new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.TXT, request.Question[0].Class, 60, new DnsTXTRecord("blockList=" + blockLists[i].AbsoluteUri + "; domain=" + request.Question[0].Name));
}
break;
default:
authority = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.SOA, request.Question[0].Class, 60, _soaRecord) };
break;
}
return(new DnsDatagram(request.Identifier, true, DnsOpcode.StandardQuery, false, false, request.RecursionDesired, true, false, false, DnsResponseCode.NoError, request.Question, answers, authority));
}
/// <summary>
/// loads and verifies the dnsrecords from the bin associated bin files, ensuring that the types
/// match up
/// </summary>
/// <typeparam name="T">Type of record that is expected</typeparam>
/// <param name="path">path to the bin file to be loaded</param>
/// <returns>bytes from the bin file</returns>
protected byte[] LoadAndVerifyDnsRecordFromBin <T>(string path)
{
byte[] bytes = null;
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
//Console.WriteLine("checking [{0}]", path);
bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
DnsResourceRecord rec = DnsResourceRecord.Deserialize(ref rdr);
Assert.Equal(rec.GetType(), typeof(T));
}
return(bytes);
}
void FixupTTL(DnsResourceRecordCollection matches)
{
if (matches.IsNullOrEmpty())
{
return;
}
for (int i = 0, count = matches.Count; i < count; ++i)
{
DnsResourceRecord match = matches[i];
if (match.TTL <= 0)
{
match.TTL = this.Settings.DefaultTTL;
}
}
}
/// <summary>
/// Tests equality between this NS record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return(false);
}
NSRecord nsRecord = record as NSRecord;
if (nsRecord == null)
{
return(false);
}
return(DnsStandard.Equals(m_nameserver, nsRecord.NameServer));
}
/// <summary>
/// Tests equality between this PTR record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return(false);
}
PtrRecord ptrRecord = record as PtrRecord;
if (ptrRecord == null)
{
return(false);
}
return(DnsStandard.Equals(this.m_domain, ptrRecord.m_domain));
}
/// <summary>
/// Tests equality between this CName record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return(false);
}
CNameRecord cnameRecord = record as CNameRecord;
if (cnameRecord == null)
{
return(false);
}
return(DnsStandard.Equals(m_name, cnameRecord.CName));
}
public static void SyncGlueRecords(this DnsResourceRecord record, IReadOnlyCollection <DnsResourceRecord> deletedGlueRecords, IReadOnlyCollection <DnsResourceRecord> addedGlueRecords)
{
if (record.RDATA is not DnsNSRecord nsRecord)
{
throw new InvalidOperationException();
}
bool updated = false;
List <DnsResourceRecord> updatedGlueRecords = new List <DnsResourceRecord>();
IReadOnlyList <DnsResourceRecord> existingGlueRecords = GetGlueRecords(record);
foreach (DnsResourceRecord existingGlueRecord in existingGlueRecords)
{
if (deletedGlueRecords.Contains(existingGlueRecord))
{
updated = true; //skipped to delete existing glue record
}
else
{
updatedGlueRecords.Add(existingGlueRecord);
}
}
string domain = nsRecord.NameServer;
foreach (DnsResourceRecord addedGlueRecord in addedGlueRecords)
{
switch (addedGlueRecord.Type)
{
case DnsResourceRecordType.A:
case DnsResourceRecordType.AAAA:
if (addedGlueRecord.Name.Equals(domain, StringComparison.OrdinalIgnoreCase))
{
updatedGlueRecords.Add(addedGlueRecord);
updated = true;
}
break;
}
}
if (updated)
{
SetGlueRecords(record, updatedGlueRecords);
}
}
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);
}
}
}
public int RemoveExpiredRecords(bool serveStale)
{
int removedEntries = 0;
foreach (KeyValuePair <DnsResourceRecordType, IReadOnlyList <DnsResourceRecord> > entry in _entries)
{
if (DnsResourceRecord.IsRRSetExpired(entry.Value, serveStale))
{
if (_entries.TryRemove(entry.Key, out _)) //RR Set is expired; remove entry
{
removedEntries++;
}
}
}
return(removedEntries);
}
public static async Task <StubZone> CreateAsync(DnsServer dnsServer, string name, string primaryNameServerAddresses = null)
{
StubZone stubZone = new StubZone(name);
stubZone._dnsServer = dnsServer;
DnsQuestionRecord soaQuestion = new DnsQuestionRecord(name, DnsResourceRecordType.SOA, DnsClass.IN);
DnsDatagram soaResponse = null;
if (primaryNameServerAddresses == null)
{
soaResponse = await stubZone._dnsServer.DirectQueryAsync(soaQuestion);
}
else
{
DnsClient dnsClient = new DnsClient(primaryNameServerAddresses);
dnsClient.Proxy = stubZone._dnsServer.Proxy;
dnsClient.PreferIPv6 = stubZone._dnsServer.PreferIPv6;
soaResponse = await dnsClient.ResolveAsync(soaQuestion);
}
if ((soaResponse == null) || (soaResponse.Answer.Count == 0) || (soaResponse.Answer[0].Type != DnsResourceRecordType.SOA))
{
throw new DnsServerException("DNS Server failed to find SOA record for: " + name);
}
DnsSOARecord receivedSoa = soaResponse.Answer[0].RDATA as DnsSOARecord;
DnsSOARecord soa = new DnsSOARecord(receivedSoa.PrimaryNameServer, receivedSoa.ResponsiblePerson, receivedSoa.Serial - 1, receivedSoa.Refresh, receivedSoa.Retry, receivedSoa.Expire, receivedSoa.Minimum);
DnsResourceRecord[] soaRR = new DnsResourceRecord[] { new DnsResourceRecord(stubZone._name, DnsResourceRecordType.SOA, DnsClass.IN, soa.Refresh, soa) };
if (!string.IsNullOrEmpty(primaryNameServerAddresses))
{
soaRR[0].SetGlueRecords(primaryNameServerAddresses);
}
stubZone._entries[DnsResourceRecordType.SOA] = soaRR;
stubZone._isExpired = true; //new stub zone is considered expired till it refreshes
stubZone._refreshTimer = new Timer(stubZone.RefreshTimerCallback, null, Timeout.Infinite, Timeout.Infinite);
return(stubZone);
}
public void Add(DnsResourceRecord record)
{
if (record == null)
{
throw new ArgumentNullException();
}
DnsResourceRecordCollection recordList;
if (!m_records.TryGetValue(record.Name, out recordList))
{
recordList = new DnsResourceRecordCollection();
m_records.Add(record.Name, recordList);
}
recordList.Add(record);
}
public SecondaryZone(DnsServer dnsServer, string name, string primaryNameServerAddresses = null)
: base(name)
{
_dnsServer = dnsServer;
DnsQuestionRecord soaQuestion = new DnsQuestionRecord(name, DnsResourceRecordType.SOA, DnsClass.IN);
DnsDatagram soaResponse = null;
if (primaryNameServerAddresses == null)
{
soaResponse = _dnsServer.DirectQuery(soaQuestion);
}
else
{
DnsClient dnsClient = new DnsClient(primaryNameServerAddresses);
dnsClient.Proxy = _dnsServer.Proxy;
dnsClient.PreferIPv6 = _dnsServer.PreferIPv6;
dnsClient.Retries = _dnsServer.Retries;
dnsClient.Timeout = _dnsServer.Timeout;
soaResponse = dnsClient.Resolve(soaQuestion);
}
if ((soaResponse == null) || (soaResponse.Answer.Count == 0) || (soaResponse.Answer[0].Type != DnsResourceRecordType.SOA))
{
throw new DnsServerException("DNS Server failed to find SOA record for: " + name);
}
DnsSOARecord receivedSoa = soaResponse.Answer[0].RDATA as DnsSOARecord;
DnsSOARecord soa = new DnsSOARecord(receivedSoa.PrimaryNameServer, receivedSoa.ResponsiblePerson, receivedSoa.Serial - 1, receivedSoa.Refresh, receivedSoa.Retry, receivedSoa.Expire, receivedSoa.Minimum);
DnsResourceRecord[] soaRR = new DnsResourceRecord[] { new DnsResourceRecord(_name, DnsResourceRecordType.SOA, DnsClass.IN, soa.Refresh, soa) };
if (!string.IsNullOrEmpty(primaryNameServerAddresses))
{
soaRR[0].SetGlueRecords(primaryNameServerAddresses);
}
_entries[DnsResourceRecordType.SOA] = soaRR;
_isExpired = true; //new secondary zone is considered expired till it refreshes
_refreshTimer = new Timer(RefreshTimerCallback, null, Timeout.Infinite, Timeout.Infinite);
}
public override void UpdateRecord(DnsResourceRecord oldRecord, DnsResourceRecord newRecord)
{
if (oldRecord.Type == DnsResourceRecordType.SOA)
{
throw new InvalidOperationException("Cannot update record: use SetRecords() for " + oldRecord.Type.ToString() + " record");
}
if (oldRecord.Type != newRecord.Type)
{
throw new InvalidOperationException("Old and new record types do not match.");
}
DeleteRecord(oldRecord.Type, oldRecord.RDATA, out DnsResourceRecord deletedRecord);
base.AddRecord(newRecord);
_primaryZone.CommitAndIncrementSerial(new DnsResourceRecord[] { deletedRecord }, new DnsResourceRecord[] { newRecord });
_primaryZone.TriggerNotify();
}
/// <summary>
/// loads and verifies the dnsrecords from the bin associated bin files, ensuring that the types
/// match up
/// </summary>
/// <typeparam name="T">Type of record that is expected</typeparam>
/// <param name="path">path to the bin file to be loaded</param>
/// <returns>bytes from the bin file</returns>
protected T LoadAndVerifyDnsRecordFromBin <T>(string path) where T : DnsResourceRecord
{
T record;
//----------------------------------------------------------------------------------------------------
//---read the stream from the bytes
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
byte[] bytes = new BinaryReader(fs).ReadBytes((int)new FileInfo(path).Length);
DnsBufferReader rdr = new DnsBufferReader(bytes, 0, bytes.Length);
record = DnsResourceRecord.Deserialize(ref rdr) as T;
if (record == null)
{
throw new TypeLoadException("unexpected type encountered in file");
}
}
return(record);
}
public void SetRecords(string domain, DnsResourceRecordType type, uint ttl, DnsResourceRecordData[] records)
{
DnsResourceRecord[] resourceRecords = new DnsResourceRecord[records.Length];
for (int i = 0; i < records.Length; i++)
{
resourceRecords[i] = new DnsResourceRecord(domain, type, DnsClass.IN, ttl, records[i]);
}
AuthZone zone = GetOrAddSubDomainZone(domain);
zone.SetRecords(type, resourceRecords);
if (zone is SubDomainZone)
{
(zone as SubDomainZone).AutoUpdateState();
}
}
public static IReadOnlyList <DnsResourceRecord> GetGlueRecords(this DnsResourceRecord record)
{
DnsResourceRecordInfo rrInfo = record.Tag as DnsResourceRecordInfo;
if (rrInfo == null)
{
return(Array.Empty <DnsResourceRecord>());
}
IReadOnlyList <DnsResourceRecord> glueRecords = rrInfo.GlueRecords;
if (glueRecords == null)
{
return(Array.Empty <DnsResourceRecord>());
}
return(glueRecords);
}
private void ResolveAdditionalRecords(DnsResourceRecord refRecord, string domain, bool serveStale, List <DnsResourceRecord> additionalRecords)
{
IReadOnlyList <DnsResourceRecord> glueRecords = refRecord.GetGlueRecords();
if (glueRecords.Count > 0)
{
bool added = false;
foreach (DnsResourceRecord glueRecord in glueRecords)
{
if (!glueRecord.IsStale)
{
added = true;
additionalRecords.Add(glueRecord);
}
}
if (added)
{
return;
}
}
CacheZone cacheZone = _root.FindZone(domain, out _, out _, out _);
if (cacheZone != null)
{
{
IReadOnlyList <DnsResourceRecord> records = cacheZone.QueryRecords(DnsResourceRecordType.A, serveStale, true);
if ((records.Count > 0) && (records[0].RDATA is DnsARecord))
{
additionalRecords.AddRange(records);
}
}
{
IReadOnlyList <DnsResourceRecord> records = cacheZone.QueryRecords(DnsResourceRecordType.AAAA, serveStale, true);
if ((records.Count > 0) && (records[0].RDATA is DnsAAAARecord))
{
additionalRecords.AddRange(records);
}
}
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, string zoneName, uint appRecordTtl, string appRecordData, bool isRecursionAllowed, IDnsServer dnsServer)
{
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonCountry;
if (_mmCountryReader.TryCountry(remoteEP.Address, out CountryResponse response))
{
jsonCountry = jsonAppRecordData[response.Country.IsoCode];
if (jsonCountry == null)
{
jsonCountry = jsonAppRecordData["default"];
}
}
else
{
jsonCountry = jsonAppRecordData["default"];
}
if (jsonCountry == null)
{
return(Task.FromResult <DnsDatagram>(null));
}
string cname = jsonCountry.Value;
if (string.IsNullOrEmpty(cname))
{
return(Task.FromResult <DnsDatagram>(null));
}
IReadOnlyList <DnsResourceRecord> answers;
if (request.Question[0].Name.Equals(zoneName, StringComparison.OrdinalIgnoreCase)) //check for zone apex
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.ANAME, DnsClass.IN, appRecordTtl, new DnsANAMERecord(cname)) }
}
; //use ANAME
else
{
answers = new DnsResourceRecord[] { new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.CNAME, DnsClass.IN, appRecordTtl, new DnsCNAMERecord(cname)) }
};
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
}
/// <summary>
/// Tests equality between this TXT record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return(false);
}
MXRecord mxRecord = record as MXRecord;
if (mxRecord == null)
{
return(false);
}
return(
DnsStandard.Equals(m_exchange, mxRecord.m_exchange) &&
this.Preference == mxRecord.Preference
);
}
public override void SetRecords(DnsResourceRecordType type, IReadOnlyList <DnsResourceRecord> records)
{
switch (type)
{
case DnsResourceRecordType.SOA:
if ((records.Count != 1) || !records[0].Name.Equals(_name, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("Invalid SOA record.");
}
DnsResourceRecord existingSoaRecord = _entries[DnsResourceRecordType.SOA][0];
DnsResourceRecord newSoaRecord = records[0];
existingSoaRecord.CopyRecordInfoFrom(newSoaRecord);
break;
default:
throw new InvalidOperationException("Cannot set records in stub zone.");
}
}
public override void SetRecords(DnsResourceRecordType type, IReadOnlyList <DnsResourceRecord> records)
{
switch (type)
{
case DnsResourceRecordType.SOA:
if ((records.Count != 1) || !records[0].Name.Equals(_name, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("Invalid SOA record.");
}
DnsResourceRecord existingSoaRR = _entries[DnsResourceRecordType.SOA][0];
existingSoaRR.SetGlueRecords(records.GetGlueRecords());
existingSoaRR.SetComments(records[0].GetComments());
break;
default:
throw new InvalidOperationException("Cannot set records in secondary zone.");
}
}
private static Task ResolveNameServerAddressesAsync(DnsServer dnsServer, DnsResourceRecord nsRecord, List <NameServerAddress> outNameServers)
{
switch (nsRecord.Type)
{
case DnsResourceRecordType.NS:
{
string nsDomain = (nsRecord.RDATA as DnsNSRecord).NameServer;
IReadOnlyList <DnsResourceRecord> glueRecords = nsRecord.GetGlueRecords();
if (glueRecords.Count > 0)
{
foreach (DnsResourceRecord glueRecord in glueRecords)
{
switch (glueRecord.Type)
{
case DnsResourceRecordType.A:
outNameServers.Add(new NameServerAddress(nsDomain, (glueRecord.RDATA as DnsARecord).Address));
break;
case DnsResourceRecordType.AAAA:
if (dnsServer.PreferIPv6)
{
outNameServers.Add(new NameServerAddress(nsDomain, (glueRecord.RDATA as DnsAAAARecord).Address));
}
break;
}
}
return(Task.CompletedTask);
}
else
{
return(ResolveNameServerAddressesAsync(dnsServer, nsDomain, 53, DnsTransportProtocol.Udp, outNameServers));
}
}
default:
throw new InvalidOperationException();
}
}
DnsRecord Find(DnsRecord record)
{
DnsRecord[] existingRecords = Client.GetMatchingDnsRecordsByType(record.DomainName, record.RecordType);
if (existingRecords.IsNullOrEmpty())
{
return(null);
}
DnsResourceRecord testRecord = record.Deserialize();
foreach (DnsRecord existingRecord in existingRecords)
{
DnsResourceRecord rr = existingRecord.Deserialize();
if (rr.Equals(testRecord))
{
return(existingRecord);
}
}
return(null);
}
public static void SyncGlueRecords(this DnsResourceRecord record, IReadOnlyList <DnsResourceRecord> allGlueRecords)
{
string domain;
switch (record.Type)
{
case DnsResourceRecordType.NS:
domain = (record.RDATA as DnsNSRecord).NameServer;
break;
case DnsResourceRecordType.SOA:
domain = (record.RDATA as DnsSOARecord).PrimaryNameServer;
break;
default:
throw new NotSupportedException();
}
List <DnsResourceRecord> foundGlueRecords = new List <DnsResourceRecord>(2);
foreach (DnsResourceRecord glueRecord in allGlueRecords)
{
switch (glueRecord.Type)
{
case DnsResourceRecordType.A:
case DnsResourceRecordType.AAAA:
if (glueRecord.Name.Equals(domain, StringComparison.OrdinalIgnoreCase))
{
foundGlueRecords.Add(glueRecord);
}
break;
}
}
if (foundGlueRecords.Count > 0)
{
SetGlueRecords(record, foundGlueRecords);
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, string zoneName, uint appRecordTtl, string appRecordData, bool isRecursionAllowed, IDnsServer dnsServer)
{
DnsResourceRecord answer;
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
if (remoteEP.AddressFamily == AddressFamily.InterNetwork)
{
answer = new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.A, DnsClass.IN, appRecordTtl, new DnsARecord(remoteEP.Address));
}
else
{
return(Task.FromResult <DnsDatagram>(null));
}
break;
case DnsResourceRecordType.AAAA:
if (remoteEP.AddressFamily == AddressFamily.InterNetworkV6)
{
answer = new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.AAAA, DnsClass.IN, appRecordTtl, new DnsAAAARecord(remoteEP.Address));
}
else
{
return(Task.FromResult <DnsDatagram>(null));
}
break;
case DnsResourceRecordType.TXT:
answer = new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.TXT, DnsClass.IN, appRecordTtl, new DnsTXTRecord(remoteEP.Address.ToString()));
break;
default:
return(Task.FromResult <DnsDatagram>(null));
}
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, new DnsResourceRecord[] { answer })));
}
public DnsResourceRecordInfo(BinaryReader bR)
{
byte version = bR.ReadByte();
switch (version)
{
case 1:
_disabled = bR.ReadBoolean();
break;
case 2:
case 3:
_disabled = bR.ReadBoolean();
int count = bR.ReadByte();
if (count > 0)
{
DnsResourceRecord[] glueRecords = new DnsResourceRecord[count];
for (int i = 0; i < glueRecords.Length; i++)
{
glueRecords[i] = new DnsResourceRecord(bR.BaseStream);
}
_glueRecords = glueRecords;
}
if (version >= 3)
{
_comments = bR.ReadShortString();
}
break;
default:
throw new InvalidDataException("DnsResourceRecordInfo format version not supported.");
}
}
public void IncrementSoaSerial()
{
DnsResourceRecord record = _entries[DnsResourceRecordType.SOA][0];
DnsSOARecord soa = record.RDATA as DnsSOARecord;
uint serial = soa.Serial;
if (serial < uint.MaxValue)
{
serial++;
}
else
{
serial = 0;
}
DnsResourceRecord newRecord = new DnsResourceRecord(record.Name, record.Type, record.Class, record.TtlValue, new DnsSOARecord(soa.PrimaryNameServer, soa.ResponsiblePerson, serial, soa.Refresh, soa.Retry, soa.Expire, soa.Minimum))
{
Tag = record.Tag
};
_entries[DnsResourceRecordType.SOA] = new DnsResourceRecord[] { newRecord };
}
bool RetrieveDnsResponse(UdpSocket socket, UInt16 transactionID, out DnsResponse dnsResponse, Int64 timeoutInMachineTicks)
{
byte[] dnsFrameBuffer = new byte[DNS_FRAME_BUFFER_LENGTH];
while (timeoutInMachineTicks > Microsoft.SPOT.Hardware.Utility.GetMachineTime().Ticks)
{
Int32 bytesReceived = socket.Receive(dnsFrameBuffer, 0, dnsFrameBuffer.Length, 0, timeoutInMachineTicks);
if (bytesReceived == 0) // timeout
{
break;
}
/* parse our DNS response */
Int32 bufferIndex = 0;
// verify that the transaction ID matches
UInt16 verifyTransactionID = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
if (transactionID != verifyTransactionID)
continue; /* filter out this DHCP frame */
// Flags
UInt16 flags = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
DnsResponseCode responseCode = (DnsResponseCode)(flags & 0x0F);
// Query Count
UInt16 queryCount = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
// Answer Record Count
UInt16 answerRecordCount = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
// Authority Record Count
UInt16 authorityRecordCount = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
// Additional Information Record Count
UInt16 additionalInformationRecordCount = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
/* parse our query records */
string queryName = "";
DnsRecordType queryType = (DnsRecordType)0;
for (int iRecord = 0; iRecord < queryCount; iRecord++)
{
// Query Name
bufferIndex += ParseDnsName(dnsFrameBuffer, bufferIndex, out queryName);
queryType = (DnsRecordType)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
UInt16 queryClass = (UInt16)(
(UInt16)(dnsFrameBuffer[bufferIndex++] << 8) +
(UInt16)(dnsFrameBuffer[bufferIndex++])
);
if (queryClass != DNS_RECORD_CLASS_INTERNET)
continue; /* filter out the current query */
}
/* parse our answer records */
DnsResourceRecord[] answerRecords = new DnsResourceRecord[answerRecordCount];
for (int iRecord = 0; iRecord < answerRecordCount; iRecord++)
{
// store answer record
bufferIndex += ParseResourceRecord(dnsFrameBuffer, bufferIndex, out answerRecords[iRecord]);
}
/* parse our authority records */
DnsResourceRecord[] authorityRecords = new DnsResourceRecord[authorityRecordCount];
for (int iRecord = 0; iRecord < authorityRecordCount; iRecord++)
{
// store authority record
bufferIndex += ParseResourceRecord(dnsFrameBuffer, bufferIndex, out authorityRecords[iRecord]);
}
/* parse our authority records */
DnsResourceRecord[] additionalInformationRecords = new DnsResourceRecord[additionalInformationRecordCount];
for (int iRecord = 0; iRecord < additionalInformationRecordCount; iRecord++)
{
// store authority record
bufferIndex += ParseResourceRecord(dnsFrameBuffer, bufferIndex, out additionalInformationRecords[iRecord]);
}
dnsResponse = new DnsResponse(responseCode, queryType, queryName, answerRecords, authorityRecords, additionalInformationRecords);
return true;
}
// if we did not receive a message before timeout, return false.
dnsResponse = null;
return false;
}
/* this function returns the number of bytes processed */
Int32 ParseResourceRecord(byte[] buffer, Int32 offset, out DnsResourceRecord resourceRecord)
{
Int32 bytesProcessed = 0;
// Name
string name;
int dnsNameBytesProcessed = ParseDnsName(buffer, offset, out name);
bytesProcessed += dnsNameBytesProcessed;
offset += bytesProcessed;
// Type
DnsRecordType recordType = (DnsRecordType)(
(UInt16)(buffer[offset++] << 8) +
(UInt16)(buffer[offset++])
);
bytesProcessed += 2;
// Class
UInt16 recordClass = (UInt16)(
(UInt16)(buffer[offset++] << 8) +
(UInt16)(buffer[offset++])
);
bytesProcessed += 2;
// TTL
UInt32 timeToLive = (
(UInt32)(buffer[offset++] << 24) +
(UInt32)(buffer[offset++] << 16) +
(UInt32)(buffer[offset++] << 8) +
(UInt32)(buffer[offset++])
);
bytesProcessed += 4;
// RDLENGTH
UInt16 dataLength = (UInt16)(
(UInt16)(buffer[offset++] << 8) +
(UInt16)(buffer[offset++])
);
bytesProcessed += 2;
// RDATA
byte[] data = new byte[dataLength];
Array.Copy(buffer, offset, data, 0, dataLength);
offset += dataLength;
bytesProcessed += dataLength;
if (recordClass == DNS_RECORD_CLASS_INTERNET)
{
resourceRecord = new DnsResourceRecord(name, recordType, timeToLive, data);
}
else
{
/* filter out the current query */
resourceRecord = new DnsResourceRecord();
}
return bytesProcessed;
}
/// <summary>
/// Tests equality between this TXT record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
MXRecord mxRecord = record as MXRecord;
if (mxRecord == null)
{
return false;
}
return (
DnsStandard.Equals(m_exchange, mxRecord.m_exchange)
&& this.Preference == mxRecord.Preference
);
}
/// <summary>
/// Tests equality between this SOA record and the other <paramref name="record"/>.
/// </summary>
/// <param name="record">The other record.</param>
/// <returns><c>true</c> if the RRs are equal, <c>false</c> otherwise.</returns>
public override bool Equals(DnsResourceRecord record)
{
if (!base.Equals(record))
{
return false;
}
SOARecord soaRecord = record as SOARecord;
if (soaRecord == null)
{
return false;
}
return (
DnsStandard.Equals(m_mname, soaRecord.m_mname)
&& DnsStandard.Equals(m_rname, soaRecord.m_rname)
&& this.SerialNumber == soaRecord.SerialNumber
&& this.Refresh == soaRecord.Refresh
&& this.Retry == soaRecord.Retry
&& this.Expire == soaRecord.Expire
&& this.Minimum == soaRecord.Minimum
);
}
