internal static DnsDataResourceRecord Parse(DnsDatagram dns, int offsetInDns, out int numBytesRead)
{
DnsDomainName domainName;
DnsType type;
DnsClass dnsClass;
if (!DnsResourceRecord.TryParseBase(dns, offsetInDns, out domainName, out type, out dnsClass, out numBytesRead))
{
return((DnsDataResourceRecord)null);
}
if (offsetInDns + numBytesRead + 6 > dns.Length)
{
return((DnsDataResourceRecord)null);
}
int ttl = dns.ReadInt(offsetInDns + numBytesRead, Endianity.Big);
ushort num = dns.ReadUShort(offsetInDns + numBytesRead + 4, Endianity.Big);
numBytesRead += 6;
if (offsetInDns + numBytesRead + (int)num > dns.Length)
{
return((DnsDataResourceRecord)null);
}
DnsResourceData data = DnsResourceData.Read(dns, type, offsetInDns + numBytesRead, (int)num);
if (data == null)
{
return((DnsDataResourceRecord)null);
}
numBytesRead += (int)num;
if (type == DnsType.Opt)
{
return((DnsDataResourceRecord) new DnsOptResourceRecord(domainName, dnsClass, ttl, data));
}
return(new DnsDataResourceRecord(domainName, type, dnsClass, ttl, data));
}
public static Type GetDnsResourceDataType(DnsType dnsType)
{
DnsResourceData prototype = DnsResourceData.TryGetPrototype(dnsType);
if (prototype == null)
{
return((Type)null);
}
return(prototype.GetType());
}
internal static DnsResourceData Read(DnsDatagram dns, DnsType type, int offsetInDns, int length)
{
DnsResourceData prototype = DnsResourceData.TryGetPrototype(type);
if (prototype != null)
{
return(prototype.CreateInstance(dns, offsetInDns, length));
}
return((DnsResourceData) new DnsResourceDataAnything(dns.Subsegment(offsetInDns, length)));
}
internal override int WriteData(byte[] buffer, int offset)
{
ByteArrayExtensions.Write(buffer, offset, this.Order, Endianity.Big);
ByteArrayExtensions.Write(buffer, offset + 2, this.Preference, Endianity.Big);
offset += 4;
DnsResourceData.WriteString(buffer, ref offset, this.Flags);
DnsResourceData.WriteString(buffer, ref offset, this.Services);
DnsResourceData.WriteString(buffer, ref offset, this.RegularExpression);
this.Replacement.WriteUncompressed(buffer, offset);
return(this.GetLength());
}
internal override void WriteDataSimple(byte[] buffer, int offset)
{
ByteArrayExtensions.Write(buffer, offset, this.Priority, Endianity.Big);
ByteArrayExtensions.Write(buffer, offset + 2, this.Weight, Endianity.Big);
int offset1 = offset + 4;
foreach (DataSegment str in this.Target)
{
DnsResourceData.WriteString(buffer, ref offset1, str);
}
}
internal override DnsResourceData CreateInstance(DataSegment data)
{
int offset = 0;
DataSegment dataSegment = DnsResourceData.ReadString(data, ref offset);
if (dataSegment == null)
{
return((DnsResourceData)null);
}
return((DnsResourceData) new DnsResourceDataString(dataSegment));
}
internal static List <DataSegment> ReadStrings(DataSegment data, int numExpected = 0)
{
List <DataSegment> list = new List <DataSegment>(numExpected);
int offset = 0;
while (offset != data.Length)
{
DataSegment dataSegment = DnsResourceData.ReadString(data, ref offset);
if (dataSegment == null)
{
return((List <DataSegment>)null);
}
list.Add(dataSegment);
}
return(list);
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < 8)
{
return((DnsResourceData)null);
}
ushort order = dns.ReadUShort(offsetInDns, Endianity.Big);
ushort preference = dns.ReadUShort(offsetInDns + 2, Endianity.Big);
DataSegment data = dns.Subsegment(offsetInDns + 4, length - 4);
int offset = 0;
DataSegment flags = DnsResourceData.ReadString(data, ref offset);
if (flags == null || !DnsResourceDataNamingAuthorityPointer.IsLegalFlags(flags))
{
return((DnsResourceData)null);
}
DataSegment services = DnsResourceData.ReadString(data, ref offset);
if (services == null)
{
return((DnsResourceData)null);
}
DataSegment regularExpression = DnsResourceData.ReadString(data, ref offset);
if (regularExpression == null)
{
return((DnsResourceData)null);
}
DnsDomainName domainName;
int numBytesRead;
if (!DnsDomainName.TryParse(dns, offsetInDns + 4 + offset, length - 4 - offset, out domainName, out numBytesRead))
{
return((DnsResourceData)null);
}
if (4 + offset + numBytesRead != length)
{
return((DnsResourceData)null);
}
return((DnsResourceData) new DnsResourceDataNamingAuthorityPointer(order, preference, flags, services, regularExpression, domainName));
}
internal override DnsResourceData CreateInstance(DataSegment data)
{
if (data.Length < 4)
{
return((DnsResourceData)null);
}
ushort priority = data.ReadUShort(0, Endianity.Big);
ushort weight = data.ReadUShort(2, Endianity.Big);
List <DataSegment> list = new List <DataSegment>();
int offset = 4;
while (data.Length > offset)
{
DataSegment dataSegment = DnsResourceData.ReadString(data, ref offset);
if (dataSegment == null)
{
return((DnsResourceData)null);
}
list.Add(dataSegment);
}
return((DnsResourceData) new DnsResourceDataUri(priority, weight, (IList <DataSegment>)list));
}
internal static DnsDataResourceRecord Parse(DnsDatagram dns, int offsetInDns, out int numBytesRead)
{
DnsDomainName domainName;
DnsType type;
DnsClass dnsClass;
if (!TryParseBase(dns, offsetInDns, out domainName, out type, out dnsClass, out numBytesRead))
{
return(null);
}
if (offsetInDns + numBytesRead + MinimumLengthAfterBase > dns.Length)
{
return(null);
}
int ttl = dns.ReadInt(offsetInDns + numBytesRead + OffsetAfterBase.Ttl, Endianity.Big);
ushort dataLength = dns.ReadUShort(offsetInDns + numBytesRead + OffsetAfterBase.DataLength, Endianity.Big);
numBytesRead += MinimumLengthAfterBase;
if (offsetInDns + numBytesRead + dataLength > dns.Length)
{
return(null);
}
DnsResourceData data = DnsResourceData.Read(dns, type, offsetInDns + numBytesRead, dataLength);
if (data == null)
{
return(null);
}
numBytesRead += dataLength;
if (type == DnsType.Opt)
{
return(new DnsOptResourceRecord(domainName, dnsClass, ttl, data));
}
return(new DnsDataResourceRecord(domainName, type, dnsClass, ttl, data));
}
internal override int GetLength()
{
return(DnsResourceData.GetStringLength(this.String));
}
internal DnsOptResourceRecord(DnsDomainName domainName, DnsClass dnsClass, int ttl, DnsResourceData data)
: base(domainName, DnsType.Opt, dnsClass, ttl, data)
{
}
internal override int GetLength()
{
return(4 + Enumerable.Sum <DataSegment>((IEnumerable <DataSegment>) this.Target, (Func <DataSegment, int>)(targetPart => DnsResourceData.GetStringLength(targetPart))));
}
private static void TestResourceRecordIsNotCreatedWithNewLength(DnsType dnsType, DnsResourceData resourceData, int dataLengthDiff)
{
var resourceRecord = new DnsDataResourceRecord(DnsDomainName.Root, dnsType, DnsClass.Internet, 0, resourceData);
var paddingResourceRecord = new DnsDataResourceRecord(DnsDomainName.Root, DnsType.Null, DnsClass.Internet, 0,
new DnsResourceDataAnything(new DataSegment(new byte[100 + Math.Abs(dataLengthDiff)])));
Packet packet = PacketBuilder.Build(DateTime.Now, new EthernetLayer(), new IpV4Layer(), new UdpLayer(),
new DnsLayer
{
Answers = new List<DnsDataResourceRecord>(new[]
{
resourceRecord,
paddingResourceRecord
}),
});
Assert.AreEqual(2, packet.Ethernet.IpV4.Udp.Dns.Answers.Count);
Assert.AreEqual(resourceRecord, packet.Ethernet.IpV4.Udp.Dns.Answers[0]);
Assert.AreEqual(paddingResourceRecord, packet.Ethernet.IpV4.Udp.Dns.Answers[1]);
byte[] buffer = new byte[packet.Length];
buffer.Write(0, packet.Ethernet);
const int dataLengthOffset =
EthernetDatagram.HeaderLengthValue + IpV4Datagram.HeaderMinimumLength + UdpDatagram.HeaderLength + DnsDatagram.HeaderLength + 5 + 4;
ushort oldDataLength = buffer.ReadUShort(dataLengthOffset, Endianity.Big);
ushort newDataLength = (ushort)(oldDataLength + dataLengthDiff);
buffer.Write(dataLengthOffset, newDataLength, Endianity.Big);
packet = new Packet(buffer, DateTime.Now, DataLinkKind.Ethernet);
Assert.IsFalse(packet.Ethernet.IpV4.Udp.Dns.Answers.Any());
}
public DnsDataResourceRecord(DnsDomainName domainName, DnsType type, DnsClass dnsClass, int ttl, DnsResourceData data)
: base(domainName, type, dnsClass)
{
this.Ttl = ttl;
this.Data = data;
}
internal override int GetLength()
{
return(4 + DnsResourceData.GetStringLength(this.Flags) + DnsResourceData.GetStringLength(this.Services) + DnsResourceData.GetStringLength(this.RegularExpression) + this.Replacement.NonCompressedLength);
}
internal DnsOptResourceRecord(DnsDomainName domainName, DnsClass dnsClass, int ttl, DnsResourceData data)
: base(domainName, DnsType.Opt, dnsClass, ttl, data)
{
}
internal override void WriteDataSimple(byte[] buffer, int offset)
{
DnsResourceData.WriteString(buffer, ref offset, this.String);
}
