using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Reflection;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using static DNSServer;

​

public class DNSServer

{

    private const int DNSPort = 53;

    private static Dictionary<string, string> _records; // Domain -> IP

​

    public struct DNSHeader

    {

        public ushort Id; // Identification number

        public ushort Flags; // Flags

        public ushort QuestionCount; // Number of questions

        public ushort AnswerCount; // Number of answer records

        public ushort AuthorityCount; // Number of authority records

        public ushort AdditionalCount; // Number of additional records

    }

​

    public struct DNSQuestion

    {

        public string QNAME; // Domain name being queried

        public ushort QTYPE; // Type of the query (A = 1)

        public ushort QCLASS; // Class of the query (IN = 1)

    }

​

    public struct DNSAnswer

    {

        public string NAME; // Domain name

        public ushort TYPE; // Type of the record (A = 1)

        public ushort CLASS; // Class of the record (IN = 1)

        public uint TTL; // Time to live

        public ushort RDLENGTH; // Length of the RDATA field

        public string RDATA; // The answer (IPv4 address)

    }

    public static string ConvertDomainNameFromDNSFormat(byte[] dnsFormat, int startIndex, out int bytesRead)

    {

        StringBuilder domainName = new StringBuilder();

        int index = startIndex;

        byte length;

​

        while ((length = dnsFormat[index++]) != 0)

        {

            if (domainName.Length > 0)

            {

                domainName.Append('.');

            }

            domainName.Append(Encoding.ASCII.GetString(dnsFormat, index, length));

            index += length;

        }

        bytesRead = index - startIndex;

        return domainName.ToString();

    }

​

    public static byte[] ConvertDomainNameToDNSFormat(string domainName)

    {

        List<byte> dnsFormat = new List<byte>();

        foreach (string label in domainName.Split('.'))

        {

            dnsFormat.Add((byte)label.Length);

            dnsFormat.AddRange(Encoding.ASCII.GetBytes(label));

        }

        dnsFormat.Add(0); // Null terminator

        return dnsFormat.ToArray();

    }

​

    public static byte[] ConvertIPv4AddressToBytes(string ipAddress)

    {

        return IPAddress.Parse(ipAddress).GetAddressBytes();

    }

    public static string ConvertBytesToIPv4Address(byte[] bytes) {

        return new IPAddress(bytes).ToString();

    }

​

​

    public static byte[] CreateResponsePacket(DNSHeader requestHeader, DNSQuestion requestQuestion, string ipAddress)

    {

        // Create the response header

        DNSHeader responseHeader = new DNSHeader

        {

            Id = requestHeader.Id,

            Flags = (ushort)0x8180, // Standard response, no errors

            QuestionCount = 1,

            AnswerCount = 1,

            AuthorityCount = 0,

            AdditionalCount = 0

        };

​

        // Create the answer record

        DNSAnswer responseAnswer = new DNSAnswer

        {

            NAME = requestQuestion.QNAME,

            TYPE = 1, // A record

            CLASS = 1, // IN class

            TTL = 60, // Time to live (in seconds)

            RDLENGTH = 4, // Length of IPv4 address

            RDATA = ipAddress

        };

​

        // Convert structures to byte arrays

        byte[] headerBytes = new byte[12];

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Id).Reverse().ToArray(), 0, headerBytes, 0, 2);

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Flags).Reverse().ToArray(), 0, headerBytes, 2, 2);

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.QuestionCount).Reverse().ToArray(), 0, headerBytes, 4, 2);

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AnswerCount).Reverse().ToArray(), 0, headerBytes, 6, 2);

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AuthorityCount).Reverse().ToArray(), 0, headerBytes, 8, 2);

        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AdditionalCount).Reverse().ToArray(), 0, headerBytes, 10, 2);

​

​

        byte[] questionBytes = ConvertDomainNameToDNSFormat(requestQuestion.QNAME);

        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QTYPE).Reverse().ToArray()).ToArray();

        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QCLASS).Reverse().ToArray()).ToArray();

        byte[] answerBytes = ConvertDomainNameToDNSFormat(responseAnswer.NAME);

        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TYPE).Reverse().ToArray()).ToArray();

        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.CLASS).Reverse().ToArray()).ToArray();

        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TTL).Reverse().ToArray()).ToArray();

        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.RDLENGTH).Reverse().ToArray()).ToArray();

        answerBytes = answerBytes.Concat(ConvertIPv4AddressToBytes(responseAnswer.RDATA)).ToArray();

​

        // Combine all parts

        return headerBytes.Concat(questionBytes).Concat(answerBytes).ToArray();

    }

​

    public static DNSHeader ParseDNSHeader(byte[] query) {

      DNSHeader header = new DNSHeader

      {

            Id = (ushort)(query[0] << 8 | query[1]),

            Flags = (ushort)(query[2] << 8 | query[3]),

            QuestionCount = (ushort)(query[4] << 8 | query[5]),

            AnswerCount = (ushort)(query[6] << 8 | query[7]),

            AuthorityCount = (ushort)(query[8] << 8 | query[9]),

            AdditionalCount = (ushort)(query[10] << 8 | query[11])

      };

      return header;

    }

​

     public static DNSQuestion ParseDNSQuestion(byte[] query, int offset, out int bytesRead)

     {

        string qname = ConvertDomainNameFromDNSFormat(query, offset, out bytesRead);

        offset += bytesRead;

        DNSQuestion question = new DNSQuestion

        {

            QNAME = qname,

            QTYPE = (ushort)(query[offset] << 8 | query[offset+1]),

            QCLASS = (ushort)(query[offset + 2] << 8 | query[offset + 3])

        };

        bytesRead += 4;

        return question;

    }

​

    public static void Start()

    {

        _records = new Dictionary<string, string>

        {

            { "example.com", "192.168.1.1" },

            { "google.com", "172.217.160.142" },

            { "microsoft.com", "13.77.161.179" }

        };

​

        UdpClient udpServer = new UdpClient(DNSPort);

        Console.WriteLine("DNS Server listening on port " + DNSPort);

​

        while (true)

        {

            IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);

            byte[] query = udpServer.Receive(ref remoteEndPoint);

​

            DNSHeader requestHeader = ParseDNSHeader(query);

            int bytesRead;

            DNSQuestion requestQuestion = ParseDNSQuestion(query, 12, out bytesRead);

​

            Console.WriteLine($"Received query for: {requestQuestion.QNAME}");

​

            string ipAddress;

            if (_records.TryGetValue(requestQuestion.QNAME, out ipAddress))

            {

​

                byte[] responsePacket = CreateResponsePacket(requestHeader, requestQuestion, ipAddress);

                udpServer.Send(responsePacket, responsePacket.Length, remoteEndPoint);

                Console.WriteLine($"Sent response for {requestQuestion.QNAME}: {ipAddress}");

            }

            else

            {

                // Handle unknown domain (in a real server, you'd probably forward the query)

                Console.WriteLine($"Unknown domain: {requestQuestion.QNAME}");

            }

        }

    }

​

public static void Main()

    {

        Console.WriteLine("🔍 Discovering and Running Tests...\n");

​

        int totalPassed = 0, totalFailed = 0;

​

        // Get all classes in the assembly with the [TestClass] attribute

        var testClasses = Assembly.GetExecutingAssembly()

            .GetTypes()

            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);

​

        foreach (var testClass in testClasses)

        {

            Console.WriteLine($"📌 Running tests in: {testClass.Name}");

            (int passed, int failed) = RunTests(testClass);

            totalPassed += passed;

            totalFailed += failed;

            Console.WriteLine();

        }

​

        Console.WriteLine("\n📊 FINAL SUMMARY:");

        Console.WriteLine($"✅ Total Passed: {totalPassed}");

        Console.WriteLine($"❌ Total Failed: {totalFailed}");

        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");

​

        Console.WriteLine("\n✅ Test execution completed.");

    }

​

    private static (int passed, int failed) RunTests(Type testClassType)

    {

        object testInstance = Activator.CreateInstance(testClassType);

        MethodInfo[] testMethods = testClassType

            .GetMethods(BindingFlags.Instance | BindingFlags.Public)

            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)

            .ToArray();

​

        int passed = 0, failed = 0;

​

        foreach (var method in testMethods)

        {

            try

            {

                method.Invoke(testInstance, null);

                Console.WriteLine($"  ✅ {method.Name} PASSED");

                passed++;

            }

            catch (TargetInvocationException ex)

            {

                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");

                failed++;

            }

            catch (Exception ex)

            {

                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");

                failed++;

            }

        }

​

        return (passed, failed);

    }

}

​

[TestClass]

public class DNSServerTests

{

    [TestMethod]

    public void ConvertDomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName()

    {

        // Arrange

        byte[] dnsFormat = { 3, 103, 111, 111, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 }; // "google.com"

        int startIndex = 0;

        int bytesRead;

​

        // Act

        string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);

​

        // Assert

        Assert.AreEqual("google.com", domainName);

        Assert.AreEqual(17, bytesRead);

    }

​

    [TestMethod]

    public void ConvertDomainNameFromDNSFormat_EmptyDomain_ReturnsEmptyString()

    {

      byte[] dnsFormat = { 0 };

      int startIndex = 0;

      int bytesRead;

​

      string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);

​

      Assert.AreEqual("", domainName);

      Assert.AreEqual(1, bytesRead);

    }

    [TestMethod]

    public void ConvertDomainNameToDNSFormat_ValidDomain_ReturnsCorrectByteArray()

    {

        // Arrange

        string domainName = "example.com";

​

        // Act

        byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);

​

        // Assert

        byte[] expected = { 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };

        CollectionAssert.AreEqual(expected, dnsFormat);

    }

     [TestMethod]

    public void ConvertDomainNameToDNSFormat_EmptyDomain_ReturnsCorrectByteArray()

    {

      string domainName = "";

      byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);

​

      byte[] expected = { 0 };

       CollectionAssert.AreEqual(expected, dnsFormat);

​

    }

​

    [TestMethod]

    public void ConvertIPv4AddressToBytes_ValidIPAddress_ReturnsCorrectByteArray()

    {

        // Arrange

        string ipAddress = "192.168.1.1";

​

        // Act

        byte[] ipBytes = DNSServer.ConvertIPv4AddressToBytes(ipAddress);

​

        // Assert

        byte[] expected = { 192, 168, 1, 1 };

        CollectionAssert.AreEqual(expected, ipBytes);

    }

​

    [TestMethod]

    public void ConvertBytesToIPv4Address_ValidBytes_ReturnsCorrectIpAddress() {

        byte[] bytes = { 192, 168, 1, 1 };

        string ipAddress = DNSServer.ConvertBytesToIPv4Address(bytes);

        Assert.AreEqual("192.168.1.1", ipAddress);

    }

​

    [TestMethod]

    public void CreateResponsePacket_ValidInput_ReturnsCorrectlyFormattedPacket()

    {

        // Arrange

        DNSHeader requestHeader = new DNSHeader { Id = 12345 };

        DNSQuestion requestQuestion = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };

        string ipAddress = "192.168.1.1";

​

        // Act

        byte[] responsePacket = DNSServer.CreateResponsePacket(requestHeader, requestQuestion, ipAddress);

​

        // Assert (check key parts, not the whole array)

        // Check ID

        Assert.AreEqual(12345, (ushort)(responsePacket[0] << 8 | responsePacket[1]));

        //Check Flags

        Assert.AreEqual(0x8180, (ushort)(responsePacket[2] << 8 | responsePacket[3]));

        // Check Question Count

        Assert.AreEqual(1, (ushort)(responsePacket[4] << 8 | responsePacket[5]));

        // Check Answer Count

        Assert.AreEqual(1, (ushort)(responsePacket[6] << 8 | responsePacket[7]));

​

        // Check IP Address in the answer

        Assert.AreEqual(192, responsePacket[responsePacket.Length - 4]);

        Assert.AreEqual(168, responsePacket[responsePacket.Length - 3]);

        Assert.AreEqual(1, responsePacket[responsePacket.Length - 2]);

        Assert.AreEqual(1, responsePacket[responsePacket.Length - 1]);

    }

    [TestMethod]

    public void ParseDNSHeader_ValidQuery_ParsesHeaderCorrectly()

    {

      byte[] query = new byte[12] {0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

​

      DNSHeader header = DNSServer.ParseDNSHeader(query);

​

      Assert.AreEqual(12345, header.Id);

      Assert.AreEqual(256, header.Flags);

      Assert.AreEqual(1, header.QuestionCount);

      Assert.AreEqual(0, header.AnswerCount);

      Assert.AreEqual(0, header.AuthorityCount);

      Assert.AreEqual(0, header.AdditionalCount);

​

    }

    [TestMethod]

    public void ParseDNSQuestion_ValidQuery_ParsesQuestionCorrectly() {

      byte[] query = {

            // Header (12 bytes, example)

            0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

            // Question section

            0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // example.com

            0x00, 0x01, // QTYPE (A record)

            0x00, 0x01  // QCLASS (IN class)

        };

      int offset = 12;

      int bytesRead;

      DNSQuestion question = DNSServer.ParseDNSQuestion(query, offset, out bytesRead);

​

      Assert.AreEqual("example.com", question.QNAME);

      Assert.AreEqual(1, question.QTYPE);

      Assert.AreEqual(1, question.QCLASS);

      Assert.AreEqual(17, bytesRead);

​

    }

}