/// <summary>
/// Returns a <see cref="System.String"/> representation of the specified
/// <see cref="AK.Net.Dns.DnsOpCode"/>.
/// </summary>
/// <param name="value">The operation code.</param>
/// <returns>A <see cref="System.String"/> representation of the specified
/// <see cref="AK.Net.Dns.DnsOpCode"/>.</returns>
public static string ToString(DnsOpCode value)
{
switch (value)
{
case DnsOpCode.Query:
return("QUERY");
case DnsOpCode.IQuery:
return("IQUERY");
case DnsOpCode.Status:
return("STATUS");
case DnsOpCode.Notify:
return("NOTIFY");
case DnsOpCode.Update:
return("UPDATE");
default:
#if DEBUG
throw Guard.ArgumentOutOfRange("value");
#else
return(value.ToString().ToUpperInvariant());
#endif
}
}
public DatagramDnsQuery(EndPoint sender, EndPoint recipient, int id, DnsOpCode opCode) : base(id, opCode)
{
if (recipient == null && sender == null)
{
throw new ArgumentNullException("recipient and sender");
}
Sender = sender;
Recipient = recipient;
}
public DnsHeader(Byte[] bytes, UInt32 offset)
{
id = (UInt16)((bytes[offset] << 8) |
(bytes[offset + 1]));
thirdByte = bytes[offset + 2];
fourthByte = bytes[offset + 3];
isResponseFlag = (bytes[offset + 2] & 0x80) != 0;
opCode = (DnsOpCode)((bytes[offset + 2] >> 3) & 0xF);
rCode = (DnsRCode)(bytes[offset + 3] & 0xF);
qdCount = (UInt16)((bytes[offset + 4] << 8) |
(bytes[offset + 5]));
anCount = (UInt16)((bytes[offset + 6] << 8) |
(bytes[offset + 7]));
nsCount = (UInt16)((bytes[offset + 8] << 8) |
(bytes[offset + 9]));
arCount = (UInt16)((bytes[offset + 10] << 8) |
(bytes[offset + 11]));
}
public DefaultDnsResponse(int id, DnsOpCode opCode, DnsResponseCode code)
: base(id, opCode)
{
Code = code ?? throw new ArgumentNullException(nameof(code));
}
public DefaultDnsResponse(int id, DnsOpCode opCode)
: this(id, opCode, DnsResponseCode.NOERROR)
{
}
public DatagramDnsResponse(EndPoint sender, EndPoint recipient, int id, DnsOpCode opCode, DnsResponseCode responseCode)
: base(id, opCode, responseCode)
{
Sender = sender ?? throw new ArgumentNullException(nameof(sender));
Recipient = recipient ?? throw new ArgumentNullException(nameof(recipient));
}
public DatagramDnsResponse(EndPoint sender, EndPoint recipient, int id, DnsOpCode opCode)
: this(sender, recipient, id, opCode, DnsResponseCode.NOERROR)
{
}
public DnsRequestHeader(int id, DnsOpCode queryKind)
: this(id, true, queryKind)
{
}
public DnsRequestHeader(int id, bool useRecursion, DnsOpCode queryKind)
{
Id = id;
OpCode = queryKind;
UseRecursion = useRecursion;
}
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);
}
}
}
/// <summary>
/// Writes a <see cref="AK.Net.Dns.DnsOpCode"/> to the underlying stream.
/// </summary>
/// <param name="value">The value to write.</param>
/// <exception cref="System.ObjectDisposedException">
/// Thrown when the writer has been disposed of.
/// </exception>
public void WriteOpCode(DnsOpCode value)
{
WriteUInt16((ushort)value);
}
protected AbstractDnsMessage(int id, DnsOpCode opcode)
{
Id = id;
OpCode = opcode;
leak = leakDetector.Track(this);
}
public DefaultDnsQuery(int id, DnsOpCode opCode) : base(id, opCode)
{
}
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)
{
ByteArrayExtensions.Write(buffer, offset, id, Endianity.Big);
byte num1 = (byte)0;
if (isResponse)
{
num1 |= (byte)sbyte.MinValue;
}
byte num2 = (byte)((uint)num1 | (uint)(byte)((int)opCode << 3 & 120));
if (isAuthoritiveAnswer)
{
num2 |= (byte)4;
}
if (isTruncated)
{
num2 |= (byte)2;
}
if (isRecursionDesired)
{
num2 |= (byte)1;
}
ByteArrayExtensions.Write(buffer, offset + 2, num2);
byte num3 = (byte)0;
if (isRecursionAvailable)
{
num3 |= (byte)sbyte.MinValue;
}
if (futureUse)
{
num3 |= (byte)64;
}
if (isAuthenticData)
{
num3 |= (byte)32;
}
if (isCheckingDisabled)
{
num3 |= (byte)16;
}
byte num4 = (byte)((uint)num3 | (uint)(byte)(responseCode & (DnsResponseCode)15));
ByteArrayExtensions.Write(buffer, offset + 3, num4);
DnsDomainNameCompressionData compressionData = new DnsDomainNameCompressionData(domainNameCompressionMode);
int offsetInDns = 12;
if (queries != null)
{
ByteArrayExtensions.Write(buffer, offset + 4, (ushort)queries.Count, Endianity.Big);
foreach (DnsQueryResourceRecord queryResourceRecord in (IEnumerable <DnsQueryResourceRecord>)queries)
{
offsetInDns += queryResourceRecord.Write(buffer, offset, compressionData, offsetInDns);
}
}
if (answers != null)
{
ByteArrayExtensions.Write(buffer, offset + 6, (ushort)answers.Count, Endianity.Big);
foreach (DnsDataResourceRecord dataResourceRecord in (IEnumerable <DnsDataResourceRecord>)answers)
{
offsetInDns += dataResourceRecord.Write(buffer, offset, compressionData, offsetInDns);
}
}
if (authorities != null)
{
ByteArrayExtensions.Write(buffer, offset + 8, (ushort)authorities.Count, Endianity.Big);
foreach (DnsDataResourceRecord dataResourceRecord in (IEnumerable <DnsDataResourceRecord>)authorities)
{
offsetInDns += dataResourceRecord.Write(buffer, offset, compressionData, offsetInDns);
}
}
if (additionals == null)
{
return;
}
ByteArrayExtensions.Write(buffer, offset + 10, (ushort)additionals.Count, Endianity.Big);
foreach (DnsDataResourceRecord dataResourceRecord in (IEnumerable <DnsDataResourceRecord>)additionals)
{
offsetInDns += dataResourceRecord.Write(buffer, offset, compressionData, offsetInDns);
}
}
public DnsRequestHeader(bool useRecursion, DnsOpCode queryKind)
{
Id = GetNextUniqueId();
OpCode = queryKind;
UseRecursion = useRecursion;
}
public DnsRequestHeader(DnsOpCode queryKind)
: this(true, queryKind)
{
}
