internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < ConstantPartLength + DnsDomainName.RootLength)
{
return(null);
}
DnsDomainName algorithm;
int algorithmLength;
if (!DnsDomainName.TryParse(dns, offsetInDns, length - ConstantPartLength, out algorithm, out algorithmLength))
{
return(null);
}
offsetInDns += algorithmLength;
length -= algorithmLength;
if (length < ConstantPartLength)
{
return(null);
}
uint inception = dns.ReadUInt(offsetInDns + OffsetAfterAlgorithm.Inception, Endianity.Big);
uint expiration = dns.ReadUInt(offsetInDns + OffsetAfterAlgorithm.Expiration, Endianity.Big);
DnsTransactionKeyMode mode = (DnsTransactionKeyMode)dns.ReadUShort(offsetInDns + OffsetAfterAlgorithm.Mode, Endianity.Big);
DnsResponseCode error = (DnsResponseCode)dns.ReadUShort(offsetInDns + OffsetAfterAlgorithm.Error, Endianity.Big);
int keySize = dns.ReadUShort(offsetInDns + OffsetAfterAlgorithm.KeySize, Endianity.Big);
if (length < ConstantPartLength + keySize)
{
return(null);
}
DataSegment key = dns.Subsegment(offsetInDns + OffsetAfterAlgorithm.KeyData, keySize);
int totalReadAfterAlgorithm = OffsetAfterAlgorithm.KeyData + keySize;
offsetInDns += totalReadAfterAlgorithm;
length -= totalReadAfterAlgorithm;
int otherSize = dns.ReadUShort(offsetInDns, Endianity.Big);
if (length != sizeof(ushort) + otherSize)
{
return(null);
}
DataSegment other = dns.Subsegment(offsetInDns + sizeof(ushort), otherSize);
return(new DnsResourceDataTransactionKey(algorithm, inception, expiration, mode, error, key, other));
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < ConstantPartLength + DnsDomainName.RootLength)
{
return(null);
}
DnsDomainName algorithm;
int algorithmLength;
if (!DnsDomainName.TryParse(dns, offsetInDns, length - ConstantPartLength, out algorithm, out algorithmLength))
{
return(null);
}
offsetInDns += algorithmLength;
length -= algorithmLength;
if (length < ConstantPartLength)
{
return(null);
}
UInt48 timeSigned = dns.ReadUInt48(offsetInDns + OffsetAfterAlgorithm.TimeSigned, Endianity.Big);
ushort fudge = dns.ReadUShort(offsetInDns + OffsetAfterAlgorithm.Fudge, Endianity.Big);
int messageAuthenticationCodeLength = dns.ReadUShort(offsetInDns + OffsetAfterAlgorithm.MessageAuthenticationCodeSize, Endianity.Big);
if (length < ConstantPartLength + messageAuthenticationCodeLength)
{
return(null);
}
DataSegment messageAuthenticationCode = dns.Subsegment(offsetInDns + OffsetAfterAlgorithm.MessageAuthenticationCode, messageAuthenticationCodeLength);
int totalReadAfterAlgorithm = OffsetAfterAlgorithm.MessageAuthenticationCode + messageAuthenticationCodeLength;
offsetInDns += totalReadAfterAlgorithm;
length -= totalReadAfterAlgorithm;
ushort originalId = dns.ReadUShort(offsetInDns + OffsetAfterMessageAuthenticationCode.OriginalId, Endianity.Big);
DnsResponseCode error = (DnsResponseCode)dns.ReadUShort(offsetInDns + OffsetAfterMessageAuthenticationCode.Error, Endianity.Big);
int otherLength = dns.ReadUShort(offsetInDns + OffsetAfterMessageAuthenticationCode.OtherLength, Endianity.Big);
if (length != OffsetAfterMessageAuthenticationCode.OtherData + otherLength)
{
return(null);
}
DataSegment other = dns.Subsegment(offsetInDns + OffsetAfterMessageAuthenticationCode.OtherData, otherLength);
return(new DnsResourceDataTransactionSignature(algorithm, timeSigned, fudge, messageAuthenticationCode, originalId, error, other));
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < ConstantPartLength)
{
return(null);
}
DnsType typeCovered = (DnsType)dns.ReadUShort(offsetInDns + Offset.TypeCovered, Endianity.Big);
DnsAlgorithm algorithm = (DnsAlgorithm)dns[offsetInDns + Offset.Algorithm];
byte labels = dns[offsetInDns + Offset.Labels];
uint originalTtl = dns.ReadUInt(offsetInDns + Offset.OriginalTtl, Endianity.Big);
uint signatureExpiration = dns.ReadUInt(offsetInDns + Offset.SignatureExpiration, Endianity.Big);
uint signatureInception = dns.ReadUInt(offsetInDns + Offset.SignatureInception, Endianity.Big);
ushort keyTag = dns.ReadUShort(offsetInDns + Offset.KeyTag, Endianity.Big);
offsetInDns += ConstantPartLength;
length -= ConstantPartLength;
DnsDomainName signersName;
int signersNameLength;
if (!DnsDomainName.TryParse(dns, offsetInDns, length, out signersName, out signersNameLength))
{
return(null);
}
offsetInDns += signersNameLength;
length -= signersNameLength;
DataSegment signature = dns.Subsegment(offsetInDns, length);
return(new DnsResourceDataSignature(typeCovered, algorithm, labels, originalTtl, signatureExpiration, signatureInception, keyTag, signersName, signature));
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
DnsDomainName nextDomainName;
int nextDomainNameLength;
if (!DnsDomainName.TryParse(dns, offsetInDns, length, out nextDomainName, out nextDomainNameLength))
{
return(null);
}
offsetInDns += nextDomainNameLength;
length -= nextDomainNameLength;
if (length > MaxTypeBitmapLength)
{
return(null);
}
DataSegment typeBitmap = dns.Subsegment(offsetInDns, length);
if (length != 0 && typeBitmap.Last == 0)
{
return(null);
}
return(new DnsResourceDataNextDomain(nextDomainName, typeBitmap));
}
internal static DnsResourceData Read(DnsDatagram dns, DnsType type, int offsetInDns, int length)
{
DnsResourceData prototype = TryGetPrototype(type);
if (prototype != null)
{
return(prototype.CreateInstance(dns, offsetInDns, length));
}
return(new DnsResourceDataAnything(dns.Subsegment(offsetInDns, length)));
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < ConstantPartLength)
{
return(null);
}
int hostIdentityTagLength = dns[offsetInDns + Offset.HostIdentityTagLength];
DnsPublicKeyAlgorithm publicKeyAlgorithm = (DnsPublicKeyAlgorithm)dns[offsetInDns + Offset.PublicKeyAlgorithm];
int publicKeyLength = dns.ReadUShort(offsetInDns + Offset.PublicKeyLength, Endianity.Big);
if (length < ConstantPartLength + hostIdentityTagLength + publicKeyLength)
{
return(null);
}
DataSegment hostIdentityTag = dns.Subsegment(offsetInDns + Offset.HostIdentityTag, hostIdentityTagLength);
int publicKeyOffset = offsetInDns + ConstantPartLength + hostIdentityTagLength;
DataSegment publicKey = dns.Subsegment(publicKeyOffset, publicKeyLength);
offsetInDns += ConstantPartLength + hostIdentityTagLength + publicKeyLength;
length -= ConstantPartLength + hostIdentityTagLength + publicKeyLength;
List <DnsDomainName> rendezvousServers = new List <DnsDomainName>();
while (length != 0)
{
DnsDomainName rendezvousServer;
int rendezvousServerLength;
if (!DnsDomainName.TryParse(dns, offsetInDns, length, out rendezvousServer, out rendezvousServerLength))
{
return(null);
}
rendezvousServers.Add(rendezvousServer);
offsetInDns += rendezvousServerLength;
length -= rendezvousServerLength;
}
return(new DnsResourceDataHostIdentityProtocol(hostIdentityTag, publicKeyAlgorithm, publicKey, rendezvousServers));
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < MinimumLength)
{
return(null);
}
ushort order = dns.ReadUShort(offsetInDns + Offset.Order, Endianity.Big);
ushort preference = dns.ReadUShort(offsetInDns + Offset.Preference, Endianity.Big);
DataSegment data = dns.Subsegment(offsetInDns + ConstantPartLength, length - ConstantPartLength);
int dataOffset = 0;
DataSegment flags = ReadString(data, ref dataOffset);
if (flags == null || !IsLegalFlags(flags))
{
return(null);
}
DataSegment services = ReadString(data, ref dataOffset);
if (services == null)
{
return(null);
}
DataSegment regexp = ReadString(data, ref dataOffset);
if (regexp == null)
{
return(null);
}
DnsDomainName replacement;
int replacementLength;
if (!DnsDomainName.TryParse(dns, offsetInDns + ConstantPartLength + dataOffset, length - ConstantPartLength - dataOffset,
out replacement, out replacementLength))
{
return(null);
}
if (ConstantPartLength + dataOffset + replacementLength != length)
{
return(null);
}
return(new DnsResourceDataNamingAuthorityPointer(order, preference, flags, services, regexp, replacement));
}
private static bool TryReadLabels(DnsDatagram dns, int offsetInDns, out int numBytesRead, List <DataSegment> labels)
{
numBytesRead = 0;
byte labelLength;
do
{
if (offsetInDns >= dns.Length)
{
return(false); // Can't read label's length.
}
labelLength = dns[offsetInDns];
++numBytesRead;
if (labelLength > MaxLabelLength)
{
// Compression.
if (offsetInDns + 1 >= dns.Length)
{
return(false); // Can't read compression pointer.
}
int newOffsetInDns = dns.ReadUShort(offsetInDns, Endianity.Big) & OffsetMask;
if (newOffsetInDns >= offsetInDns)
{
return(false); // Can't handle pointers that are not back pointers.
}
++numBytesRead;
int internalBytesRead;
return(TryReadLabels(dns, newOffsetInDns, out internalBytesRead, labels));
}
if (labelLength != 0)
{
++offsetInDns;
if (offsetInDns + labelLength >= dns.Length)
{
return(false); // Can't read label.
}
labels.Add(dns.Subsegment(offsetInDns, labelLength));
numBytesRead += labelLength;
offsetInDns += labelLength;
}
} while (labelLength != 0);
return(true);
}
internal override DnsResourceData CreateInstance(DnsDatagram dns, int offsetInDns, int length)
{
if (length < ConstPartLength)
{
return(null);
}
byte precedence = dns[offsetInDns + Offset.Precedence];
DnsGatewayType gatewayType = (DnsGatewayType)dns[offsetInDns + Offset.GatewayType];
DnsPublicKeyAlgorithm algorithm = (DnsPublicKeyAlgorithm)dns[offsetInDns + Offset.Algorithm];
DnsGateway gateway = DnsGateway.CreateInstance(gatewayType, dns, offsetInDns + Offset.Gateway, length - ConstPartLength);
if (gateway == null)
{
return(null);
}
DataSegment publicKey = dns.Subsegment(offsetInDns + ConstPartLength + gateway.Length, length - ConstPartLength - gateway.Length);
return(new DnsResourceDataIpSecKey(precedence, gateway, algorithm, publicKey));
}
