internal int Write(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int length = WriteData(buffer, dnsOffset, offsetInDns + sizeof(ushort), compressionData);
buffer.Write(dnsOffset + offsetInDns, (ushort)length, Endianity.Big);
length += sizeof(ushort);
return(length);
}
internal override int Write(byte[] buffer, int dnsOffset, DnsDomainNameCompressionData compressionData, int offsetInDns)
{
int length = base.Write(buffer, dnsOffset, compressionData, offsetInDns);
buffer.Write(dnsOffset + offsetInDns + length, Ttl, Endianity.Big);
length += sizeof(uint);
length += Data.Write(buffer, dnsOffset, offsetInDns + length, compressionData);
return(length);
}
internal virtual int Write(byte[] buffer, int dnsOffset, DnsDomainNameCompressionData compressionData, int offsetInDns)
{
int length = 0;
length += DomainName.Write(buffer, dnsOffset, compressionData, offsetInDns + length);
buffer.Write(dnsOffset + offsetInDns + length, (ushort)DnsType, Endianity.Big);
length += sizeof(ushort);
buffer.Write(dnsOffset + offsetInDns + length, (ushort)DnsClass, Endianity.Big);
length += sizeof(ushort);
return(length);
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
int totalLength = 0;
foreach (DnsDomainName domainName in DomainNames)
{
int length = domainName.GetLength(compressionData, offsetInDns);
offsetInDns += length;
totalLength += length;
}
return(totalLength);
}
internal static int GetLength(IEnumerable <DnsResourceRecord> resourceRecords, DnsDomainNameCompressionMode domainNameCompressionMode)
{
int length = HeaderLength;
DnsDomainNameCompressionData compressionData = new DnsDomainNameCompressionData(domainNameCompressionMode);
if (resourceRecords != null)
{
foreach (DnsResourceRecord record in resourceRecords)
{
length += record.GetLength(compressionData, length);
}
}
return(length);
}
internal int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
int length = 0;
for (int i = 0; i != LabelsCount; ++i)
{
ListSegment <DataSegment> labels = new ListSegment <DataSegment>(_labels, i);
if (compressionData.IsAvailable(labels))
{
return(length + sizeof(ushort));
}
compressionData.AddCompressionData(labels, offsetInDns + length);
length += sizeof(byte) + labels[0].Length;
}
return(length + sizeof(byte));
}
internal int Write(byte[] buffer, int dnsOffset, DnsDomainNameCompressionData compressionData, int offsetInDns)
{
int length = 0;
for (int i = 0; i != LabelsCount; ++i)
{
ListSegment <DataSegment> labels = new ListSegment <DataSegment>(_labels, i);
int pointerOffset;
if (compressionData.TryGetOffset(labels, out pointerOffset))
{
buffer.Write(dnsOffset + offsetInDns + length, (ushort)(CompressionMarker | (ushort)pointerOffset), Endianity.Big);
return(length + sizeof(ushort));
}
DataSegment currentLabel = labels[0];
compressionData.AddCompressionData(labels, offsetInDns + length);
buffer.Write(dnsOffset + offsetInDns + length, (byte)currentLabel.Length);
length += sizeof(byte);
currentLabel.Write(buffer, dnsOffset + offsetInDns + length);
length += currentLabel.Length;
}
return(length + sizeof(byte));
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(ConstantPartLength + Map822.GetLength(compressionData, offsetInDns) + MapX400.GetLength(compressionData, offsetInDns));
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int numBytesWritten = NextDomainName.Write(buffer, dnsOffset, compressionData, offsetInDns);
TypeBitmap.Write(buffer, dnsOffset + offsetInDns + numBytesWritten);
return(numBytesWritten + TypeBitmap.Length);
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
buffer.Write(dnsOffset + offsetInDns + Offset.TypeCovered, (ushort)TypeCovered, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + Offset.Algorithm, (byte)Algorithm);
buffer.Write(dnsOffset + offsetInDns + Offset.Labels, Labels);
buffer.Write(dnsOffset + offsetInDns + Offset.OriginalTtl, OriginalTtl, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + Offset.SignatureExpiration, SignatureExpiration.Value, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + Offset.SignatureInception, SignatureInception.Value, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + Offset.KeyTag, KeyTag, Endianity.Big);
int numBytesWritten = ConstantPartLength;
numBytesWritten += SignersName.Write(buffer, dnsOffset, compressionData, offsetInDns + numBytesWritten);
Signature.Write(buffer, dnsOffset + offsetInDns + numBytesWritten);
return(numBytesWritten + Signature.Length);
}
internal override int GetLengthAfterBase(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(0);
}
internal static void Write(byte[] buffer, int offset,
ushort id, bool isResponse, DnsOpCode opCode, bool isAuthoritiveAnswer, bool isTruncated,
bool isRecursionDesired, bool isRecursionAvailable, bool futureUse, bool isAuthenticData, bool isCheckingDisabled,
DnsResponseCode responseCode, IList <DnsQueryResourceRecord> queries, IList <DnsDataResourceRecord> answers,
IList <DnsDataResourceRecord> authorities, IList <DnsDataResourceRecord> additionals,
DnsDomainNameCompressionMode domainNameCompressionMode)
{
buffer.Write(offset + Offset.Id, id, Endianity.Big);
byte flags0 = 0;
if (isResponse)
{
flags0 |= Mask.IsResponse;
}
flags0 |= (byte)((((byte)opCode) << Shift.OpCode) & Mask.OpCode);
if (isAuthoritiveAnswer)
{
flags0 |= Mask.IsAuthoritiveAnswer;
}
if (isTruncated)
{
flags0 |= Mask.IsTruncated;
}
if (isRecursionDesired)
{
flags0 |= Mask.IsRecusionDesired;
}
buffer.Write(offset + Offset.IsResponse, flags0);
byte flags1 = 0;
if (isRecursionAvailable)
{
flags1 |= Mask.IsRecursionAvailable;
}
if (futureUse)
{
flags1 |= Mask.FutureUse;
}
if (isAuthenticData)
{
flags1 |= Mask.IsAuthenticData;
}
if (isCheckingDisabled)
{
flags1 |= Mask.IsCheckingDisabled;
}
flags1 |= (byte)((ushort)responseCode & Mask.ResponseCode);
buffer.Write(offset + Offset.IsRecusionAvailable, flags1);
DnsDomainNameCompressionData compressionData = new DnsDomainNameCompressionData(domainNameCompressionMode);
int recordOffset = HeaderLength;
if (queries != null)
{
buffer.Write(offset + Offset.QueryCount, (ushort)queries.Count, Endianity.Big);
foreach (DnsQueryResourceRecord record in queries)
{
recordOffset += record.Write(buffer, offset, compressionData, recordOffset);
}
}
if (answers != null)
{
buffer.Write(offset + Offset.AnswerCount, (ushort)answers.Count, Endianity.Big);
foreach (DnsDataResourceRecord record in answers)
{
recordOffset += record.Write(buffer, offset, compressionData, recordOffset);
}
}
if (authorities != null)
{
buffer.Write(offset + Offset.AuthorityCount, (ushort)authorities.Count, Endianity.Big);
foreach (DnsDataResourceRecord record in authorities)
{
recordOffset += record.Write(buffer, offset, compressionData, recordOffset);
}
}
if (additionals != null)
{
buffer.Write(offset + Offset.AdditionalCount, (ushort)additionals.Count, Endianity.Big);
foreach (DnsDataResourceRecord record in additionals)
{
recordOffset += record.Write(buffer, offset, compressionData, recordOffset);
}
}
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
buffer.Write(dnsOffset + offsetInDns + Offset.Value, Value, Endianity.Big);
int numBytesWritten = DomainName.Write(buffer, dnsOffset, compressionData, offsetInDns + Offset.DomainName);
return(ConstantPartLength + numBytesWritten);
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
return(Data.Write(buffer, dnsOffset, compressionData, offsetInDns));
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(Data.GetLength(compressionData, offsetInDns));
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int algorithmLength = Algorithm.Write(buffer, dnsOffset, compressionData, offsetInDns);
int offset = dnsOffset + offsetInDns + algorithmLength;
buffer.Write(offset + OffsetAfterAlgorithm.TimeSigned, TimeSigned, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.Fudge, Fudge, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.MessageAuthenticationCodeSize, (ushort)MessageAuthenticationCode.Length, Endianity.Big);
MessageAuthenticationCode.Write(buffer, offset + OffsetAfterAlgorithm.MessageAuthenticationCode);
offset += OffsetAfterAlgorithm.MessageAuthenticationCode + MessageAuthenticationCode.Length;
buffer.Write(offset + OffsetAfterMessageAuthenticationCode.OriginalId, OriginalId, Endianity.Big);
buffer.Write(offset + OffsetAfterMessageAuthenticationCode.Error, (ushort)Error, Endianity.Big);
buffer.Write(offset + OffsetAfterMessageAuthenticationCode.OtherLength, (ushort)Other.Length, Endianity.Big);
Other.Write(buffer, offset + OffsetAfterMessageAuthenticationCode.OtherData);
return(algorithmLength + ConstantPartLength + MessageAuthenticationCode.Length + Other.Length);
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int numBytesWritten = 0;
foreach (DnsDomainName domainName in DomainNames)
{
numBytesWritten += domainName.Write(buffer, dnsOffset, compressionData, offsetInDns + numBytesWritten);
}
return(numBytesWritten);
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
buffer.Write(dnsOffset + offsetInDns + Offset.Preference, Preference, Endianity.Big);
int numBytesWritten = Map822.Write(buffer, dnsOffset, compressionData, offsetInDns + Offset.Map822);
numBytesWritten += MapX400.Write(buffer, dnsOffset, compressionData, offsetInDns + ConstantPartLength + numBytesWritten);
return(ConstantPartLength + numBytesWritten);
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(MainNameServer.GetLength(compressionData, offsetInDns) +
ResponsibleMailbox.GetLength(compressionData, offsetInDns) +
ConstantPartLength);
}
internal abstract int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData);
internal override int GetLengthAfterBase(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(MinimumLengthAfterBase + Data.GetLength(compressionData, offsetInDns));
}
internal abstract int GetLengthAfterBase(DnsDomainNameCompressionData compressionData, int offsetInDns);
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int numBytesWritten = MainNameServer.Write(buffer, dnsOffset, compressionData, offsetInDns);
numBytesWritten += ResponsibleMailbox.Write(buffer, dnsOffset, compressionData, offsetInDns + numBytesWritten);
buffer.Write(dnsOffset + offsetInDns + numBytesWritten + Offset.Serial, Serial.Value, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + numBytesWritten + Offset.Refresh, Refresh, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + numBytesWritten + Offset.Retry, Retry, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + numBytesWritten + Offset.Expire, Expire, Endianity.Big);
buffer.Write(dnsOffset + offsetInDns + numBytesWritten + Offset.MinimumTtl, MinimumTtl, Endianity.Big);
return(numBytesWritten + ConstantPartLength);
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(ConstantPartLength + SignersName.GetLength(compressionData, offsetInDns) + Signature.Length);
}
internal int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(DomainName.GetLength(compressionData, offsetInDns) + MinimumLengthAfterDomainName + GetLengthAfterBase(compressionData, offsetInDns));
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(Algorithm.GetLength(compressionData, offsetInDns) + ConstantPartLength + Key.Length + Other.Length);
}
internal override int WriteData(byte[] buffer, int dnsOffset, int offsetInDns, DnsDomainNameCompressionData compressionData)
{
int algorithmLength = Algorithm.Write(buffer, dnsOffset, compressionData, offsetInDns);
int offset = dnsOffset + offsetInDns + algorithmLength;
buffer.Write(offset + OffsetAfterAlgorithm.Inception, Inception.Value, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.Expiration, Expiration.Value, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.Mode, (ushort)Mode, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.Error, (ushort)Error, Endianity.Big);
buffer.Write(offset + OffsetAfterAlgorithm.KeySize, (ushort)Key.Length, Endianity.Big);
Key.Write(buffer, offset + OffsetAfterAlgorithm.KeyData);
int otherSizeOffset = offset + OffsetAfterAlgorithm.KeyData + Key.Length;
buffer.Write(otherSizeOffset, (ushort)Other.Length, Endianity.Big);
Other.Write(buffer, otherSizeOffset + sizeof(ushort));
return(algorithmLength + ConstantPartLength + Key.Length + Other.Length);
}
internal override int GetLength(DnsDomainNameCompressionData compressionData, int offsetInDns)
{
return(NextDomainName.GetLength(compressionData, offsetInDns) + TypeBitmap.Length);
}
