DNS Codec

src/DotNetty.Codecs.DNS/DatagramDnsQueryDecoder.cs

@@ -0,0 +1,86 @@
+using DotNetty.Transport.Channels.Sockets;
+using System;
+using System.Collections.Generic;
+using DotNetty.Transport.Channels;
+using DotNetty.Codecs.DNS.Messages;
+using DotNetty.Buffers;
+using DotNetty.Codecs.DNS.Records;
+
+namespace DotNetty.Codecs.DNS
+{
+ public class DatagramDnsQueryDecoder : MessageToMessageDecoder<DatagramPacket>
+ {
+ private readonly IDnsRecordDecoder recordDecoder;
+
+ public DatagramDnsQueryDecoder() : this(new DefaultDnsRecordDecoder()) { }
+
+ public DatagramDnsQueryDecoder(IDnsRecordDecoder recordDecoder)
+ {
+ this.recordDecoder = recordDecoder ?? throw new ArgumentNullException(nameof(recordDecoder));
+ }
+
+ protected override void Decode(IChannelHandlerContext context, DatagramPacket message, List<object> output)
+ {
+ IByteBuffer buffer = message.Content;
+ IDnsQuery query = NewQuery(message, buffer);
+ bool success = false;
+
+ try
+ {
+ int questionCount = buffer.ReadUnsignedShort();
+ int answerCount = buffer.ReadUnsignedShort();
+ int authorityRecordCount = buffer.ReadUnsignedShort();
+ int additionalRecordCount = buffer.ReadUnsignedShort();
+
+ DecodeQuestions(query, buffer, questionCount);
+ DecodeRecords(query, DnsSection.ANSWER, buffer, answerCount);
+ DecodeRecords(query, DnsSection.AUTHORITY, buffer, authorityRecordCount);
+ DecodeRecords(query, DnsSection.ADDITIONAL, buffer, additionalRecordCount);
+
+ output.Add(query);
+ success = true;
+ }
+ finally
+ {
+ if (!success)
+ query.Release();
+ }
+ }
+
+ private static IDnsQuery NewQuery(DatagramPacket packet, IByteBuffer buffer)
+ {
+ int id = buffer.ReadUnsignedShort();
+ int flags = buffer.ReadUnsignedShort();
+ if (flags >> 15 == 1)
+ throw new CorruptedFrameException("not a query");
+
+ IDnsQuery query = new DatagramDnsQuery(
+ packet.Sender, packet.Recipient, id, 
+ DnsOpCode.From((byte)(flags >> 11 & 0xf)));
+
+ query.IsRecursionDesired = (flags >> 8 & 1) == 1;
+ query.Z = flags >> 4 & 0x7;
+ return query;
+ }
+
+ private void DecodeQuestions(IDnsQuery query, IByteBuffer buffer, int questionCount)
+ {
+ for (int i = questionCount; i > 0; i--)
+ {
+ query.AddRecord(DnsSection.QUESTION, recordDecoder.DecodeQuestion(buffer));
+ }
+ }
+
+ private void DecodeRecords(IDnsQuery query, DnsSection section, IByteBuffer buffer, int count)
+ {
+ for (int i = count; i > 0; i--)
+ {
+ IDnsRecord r = recordDecoder.DecodeRecord(buffer);
+ if (r == null)
+ break;
+
+ query.AddRecord(section, r);
+ }
+ }
+ }
+}

src/DotNetty.Codecs.DNS/DatagramDnsQueryEncoder.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using DotNetty.Transport.Channels;
+using DotNetty.Codecs.DNS.Messages;
+using DotNetty.Buffers;
+using DotNetty.Codecs.DNS.Records;
+using System.Net;
+using DotNetty.Transport.Channels.Sockets;
+
+namespace DotNetty.Codecs.DNS
+{
+ public class DatagramDnsQueryEncoder : MessageToMessageEncoder<IAddressedEnvelope<IDnsQuery>>
+ {
+ private readonly IDnsRecordEncoder recordEncoder;
+
+ public DatagramDnsQueryEncoder() : this(new DefaultDnsRecordEncoder()) { }
+
+ public DatagramDnsQueryEncoder(IDnsRecordEncoder recordEncoder)
+ {
+ this.recordEncoder = recordEncoder ?? throw new ArgumentNullException(nameof(recordEncoder));
+ }
+
+ protected override void Encode(IChannelHandlerContext context, IAddressedEnvelope<IDnsQuery> message, List<object> output)
+ {
+ EndPoint recipient = message.Recipient;
+ IDnsQuery query = message.Content;
+ IByteBuffer buffer = AllocateBuffer(context, message);
+ bool success = false;
+
+ try
+ {
+ EncodeHeader(query, buffer);
+ EncodeQuestions(query, buffer);
+ EncodeRecords(query, DnsSection.ADDITIONAL, buffer);
+ success = true;
+ }
+ finally
+ {
+ if (!success)
+ buffer.Release();
+ }
+
+ output.Add(new DatagramPacket(buffer, recipient, null));
+ }
+
+ private IByteBuffer AllocateBuffer(IChannelHandlerContext ctx, 
+ IAddressedEnvelope<IDnsQuery> message) => ctx.Allocator.Buffer(1024);
+
+ private void EncodeHeader(IDnsQuery query, IByteBuffer buffer)
+ {
+ buffer.WriteShort(query.Id);
+ int flags = 0;
+ flags |= (query.OpCode.ByteValue & 0xFF) << 14;
+ if (query.IsRecursionDesired)
+ flags |= 1 << 8;
+
+ buffer.WriteShort(flags);
+ buffer.WriteShort(query.Count(DnsSection.QUESTION));
+ buffer.WriteShort(0);
+ buffer.WriteShort(0);
+ buffer.WriteShort(query.Count(DnsSection.ADDITIONAL));
+ }
+
+ private void EncodeQuestions(IDnsQuery query, IByteBuffer buffer)
+ {
+ int count = query.Count(DnsSection.QUESTION);
+ for (int i = 0; i < count; i++)
+ {
+ recordEncoder.EncodeQuestion(query.GetRecord<IDnsQuestion>(DnsSection.QUESTION, i), buffer);
+ }
+ }
+
+ private void EncodeRecords(IDnsQuery query, DnsSection section, IByteBuffer buffer)
+ {
+ int count = query.Count(section);
+ for (int i = 0; i < count; i++)
+ {
+ recordEncoder.EncodeRecord(query.GetRecord<IDnsRecord>(section, i), buffer);
+ }
+ }
+ }
+}

src/DotNetty.Codecs.DNS/DatagramDnsResponseDecoder.cs

@@ -0,0 +1,85 @@
+using DotNetty.Transport.Channels.Sockets;
+using System;
+using System.Collections.Generic;
+using DotNetty.Transport.Channels;
+using DotNetty.Codecs.DNS.Messages;
+using DotNetty.Buffers;
+using DotNetty.Codecs.DNS.Records;
+
+namespace DotNetty.Codecs.DNS
+{
+ public class DatagramDnsResponseDecoder : MessageToMessageDecoder<DatagramPacket>
+ {
+ private readonly IDnsRecordDecoder recordDecoder;
+
+ public DatagramDnsResponseDecoder() : this(new DefaultDnsRecordDecoder()) { }
+
+ public DatagramDnsResponseDecoder(IDnsRecordDecoder recordDecoder)
+ {
+ this.recordDecoder = recordDecoder ?? throw new ArgumentNullException(nameof(recordDecoder));
+ }
+
+ protected override void Decode(IChannelHandlerContext context, DatagramPacket message, List<object> output)
+ {
+ IByteBuffer buffer = message.Content;
+ IDnsResponse response = NewResponse(message, buffer);
+ bool success = false;
+
+ try
+ {
+ int questionCount = buffer.ReadUnsignedShort();
+ int answerCount = buffer.ReadUnsignedShort();
+ int authorityRecordCount = buffer.ReadUnsignedShort();
+ int additionalRecordCount = buffer.ReadUnsignedShort();
+
+ DecodeQuestions(response, buffer, questionCount);
+ DecodeRecords(response, DnsSection.ANSWER, buffer, answerCount);
+ DecodeRecords(response, DnsSection.AUTHORITY, buffer, authorityRecordCount);
+ DecodeRecords(response, DnsSection.ADDITIONAL, buffer, additionalRecordCount);
+
+ output.Add(response);
+ success = true;
+ }
+ finally
+ {
+ if (!success)
+ response.Release();
+ }
+ }
+
+ private static IDnsResponse NewResponse(DatagramPacket packet, IByteBuffer buffer)
+ {
+ int id = buffer.ReadUnsignedShort();
+ int flags = buffer.ReadUnsignedShort();
+ if (flags >> 15 == 0) throw new CorruptedFrameException("not a response");
+
+ IDnsResponse response = new DatagramDnsResponse(
+ packet.Sender, 
+ packet.Recipient, 
+ id, 
+ DnsOpCode.From((byte)(flags >> 1 & 0xf)), 
+ DnsResponseCode.From((byte)(flags & 0xf)));
+ return response;
+ }
+
+ private void DecodeQuestions(IDnsResponse response, IByteBuffer buffer, int questionCount)
+ {
+ for (int i = questionCount - 1; i > 0; i--)
+ {
+ response.AddRecord(DnsSection.QUESTION, recordDecoder.DecodeQuestion(buffer));
+ }
+ }
+
+ private void DecodeRecords(IDnsResponse response, DnsSection section, IByteBuffer buffer, int count)
+ {
+ for (int i = count - 1; i > 0; i--)
+ {
+ IDnsRecord r = recordDecoder.DecodeRecord(buffer);
+ if (r == null)
+ break;
+
+ response.AddRecord(section, r);
+ }
+ }
+ }
+}

src/DotNetty.Codecs.DNS/DatagramDnsResponseEncoder.cs

@@ -0,0 +1,97 @@
+using DotNetty.Buffers;
+using DotNetty.Codecs.DNS.Messages;
+using DotNetty.Codecs.DNS.Records;
+using DotNetty.Transport.Channels;
+using DotNetty.Transport.Channels.Sockets;
+using System;
+using System.Collections.Generic;
+using System.Net;
+
+namespace DotNetty.Codecs.DNS
+{
+ public class DatagramDnsResponseEncoder : MessageToMessageEncoder<IAddressedEnvelope<IDnsResponse>>
+ {
+ private IDnsRecordEncoder recordEncoder;
+
+ public DatagramDnsResponseEncoder() : this(new DefaultDnsRecordEncoder()) { }
+
+ public DatagramDnsResponseEncoder(IDnsRecordEncoder recordEncoder)
+ {
+ this.recordEncoder = recordEncoder ?? throw new ArgumentNullException(nameof(recordEncoder));
+ }
+
+ protected override void Encode(IChannelHandlerContext context, IAddressedEnvelope<IDnsResponse> message, List<object> output)
+ {
+ EndPoint recipient = message.Recipient;
+ IDnsResponse response = message.Content;
+ IByteBuffer buffer = AllocateBuffer(context, message);
+
+ bool success = false;
+ try
+ {
+ EncodeHeader(response, buffer);
+ EncodeQuestions(response, buffer);
+ EncodeRecords(response, DnsSection.ANSWER, buffer);
+ EncodeRecords(response, DnsSection.AUTHORITY, buffer);
+ EncodeRecords(response, DnsSection.ADDITIONAL, buffer);
+ success = true;
+ }
+ finally
+ {
+ if (!success)
+ buffer.Release();
+ }
+
+ output.Add(new DatagramPacket(buffer, recipient, null));
+ }
+
+ protected IByteBuffer AllocateBuffer(IChannelHandlerContext ctx,
+ IAddressedEnvelope<IDnsResponse> message) => ctx.Allocator.Buffer(1024);
+
+ private static void EncodeHeader(IDnsResponse response, IByteBuffer buffer)
+ {
+ buffer.WriteShort(response.Id);
+ int flags = 32768;
+ flags |= (response.OpCode.ByteValue & 0xFF) << 11;
+ if (response.IsAuthoritativeAnswer)
+ flags |= 1 << 10;
+
+ if (response.IsTruncated)
+ flags |= 1 << 9;
+
+ if (response.IsRecursionDesired)
+ flags |= 1 << 8;
+
+ if (response.IsRecursionAvailable)
+ flags |= 1 << 7;
+
+ flags |= response.Z << 4;
+ flags |= response.Code.IntValue;
+ buffer.WriteShort(flags);
+ buffer.WriteShort(response.Count(DnsSection.QUESTION));
+ buffer.WriteShort(response.Count(DnsSection.ANSWER));
+ buffer.WriteShort(response.Count(DnsSection.AUTHORITY));
+ buffer.WriteShort(response.Count(DnsSection.ADDITIONAL));
+ }
+
+ private void EncodeQuestions(IDnsResponse response, IByteBuffer buffer)
+ {
+ int count = response.Count(DnsSection.QUESTION);
+ for (int i = 0; i < count; i++)
+ {
+ recordEncoder.EncodeQuestion(response.GetRecord<IDnsQuestion>(DnsSection.QUESTION, i), buffer);
+ }
+ }
+
+ private void EncodeRecords(IDnsResponse response, DnsSection section, IByteBuffer buffer)
+ {
+ int count = response.Count(section);
+ for (int i = 0; i < count; i++)
+ {
+ recordEncoder.EncodeRecord(response.GetRecord<IDnsRecord>(section, i), buffer);
+ }
+ }
+
+
+ }
+}