Added UDP and TCP dns servers and associated tests

CMakeLists.txt

@@ -14,5 +14,9 @@ add_executable(${PROJECT_NAME}
         )
 
 add_subdirectory(src/modules/dns-base)
+add_subdirectory(src/modules/dns-server)
 
-target_link_libraries(${PROJECT_NAME} Qt5::Core qdnsagg-dns-base)
+include_directories(src/modules/dns-base/includes)
+include_directories(src/modules/dns-server/includes)
+
+target_link_libraries(${PROJECT_NAME} Qt5::Core qdnsagg-dns-base qdnsagg-dns-server)

src/main.cpp

@@ -1,9 +1,36 @@
 #include <iostream>
 #include <QCoreApplication>
+#include "dns-server/QUdpDnsServer.h"
+#include "dns-server/QTcpDnsServer.h"
+#include "dns-base/QDnsBase.h"
 
 int main(int argc, char* argv[])
 {
     QCoreApplication app(argc, argv);
-    std::cout << "Hello, World!" << std::endl;
+
+    QHostAddress bindAddress("127.0.0.1");
+    quint16 bindPort = 5053;
+
+    auto onRequest = [](QDns::Server::QUdpDnsServer::OnRequestParams params)
+    {
+        QDns::Base::QDnsPacket answer = params.packet.makeAnswer();
+        auto header = answer.getHeader();
+        header.setReplyCode(QDns::Base::HeaderReplyCode::Refused);
+        answer.setHeader(header);
+
+        params.sendAnswer(QDns::Server::QDnsServer::SendAnswerParams
+                                  {
+                                          answer
+                                  });
+    };
+
+    QDns::Server::QTcpDnsServer tcpServer;
+    tcpServer.start(bindAddress, bindPort);
+    QObject::connect(&tcpServer, &QDns::Server::QDnsServer::onRequest, onRequest);
+
+    QDns::Server::QUdpDnsServer udpServer;
+    udpServer.start(bindAddress, bindPort);
+    QObject::connect(&udpServer, &QDns::Server::QDnsServer::onRequest, onRequest);
+
     return app.exec();
 }

src/modules/dns-server/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-dns-server)
+enable_testing()
+
+include_directories(includes ../dns-base/includes)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
+
+add_library(${PROJECT_NAME}
+        src/QDnsServer.cpp
+        includes/dns-server/QDnsServer.h
+        src/QUdpDnsServer.cpp
+        includes/dns-server/QUdpDnsServer.h
+        src/QTcpDnsServer.cpp
+        includes/dns-server/QTcpDnsServer.h
+        src/QTcpDnsServerClient.cpp
+        src/QTcpDnsServerClient.h)
+
+target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network qdnsagg-dns-base)
+
+find_package(GTest)
+if (GTEST_FOUND)
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

src/modules/dns-server/includes/dns-server/QDnsServer.h

@@ -0,0 +1,44 @@
+//
+// Created by robin on 1/31/18.
+//
+
+#ifndef QDNSAGG_QDNSSERVER_H
+#define QDNSAGG_QDNSSERVER_H
+
+#include <QtCore/QObject>
+#include <dns-base/QDnsPacket.h>
+#include <QtNetwork/QHostAddress>
+#include <functional>
+
+namespace QDns
+{
+    namespace Server
+    {
+        class QDnsServer : public QObject
+        {
+            Q_OBJECT
+        public:
+            struct SendAnswerParams
+            {
+                QDns::Base::QDnsPacket answer;
+            };
+
+            struct OnRequestParams
+            {
+                QDns::Base::QDnsPacket packet;
+                QHostAddress senderAddress;
+                quint16 senderPort;
+                std::function<void(SendAnswerParams)> sendAnswer;
+            };
+
+        signals:
+            void onRequest(OnRequestParams params);
+
+        public slots:
+            virtual bool start(const QHostAddress& host, quint16 port) = 0;
+        };
+    }
+}
+
+
+#endif //QDNSAGG_QDNSSERVER_H

src/modules/dns-server/includes/dns-server/QTcpDnsServer.h

@@ -0,0 +1,37 @@
+//
+// Created by robin on 1/31/18.
+//
+
+#ifndef QDNSAGG_QTCPDNSSERVER_H
+#define QDNSAGG_QTCPDNSSERVER_H
+
+#include <QTcpServer>
+#include "QDnsServer.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+        class QTcpDnsServerClient;
+
+        class QTcpDnsServer : public QDnsServer
+        {
+            Q_OBJECT
+        public:
+            QTcpDnsServer();
+
+        public slots:
+            bool start(const QHostAddress& host, quint16 port) override;
+
+        private slots:
+            void onNewConnection();
+
+        private:
+            QTcpServer* m_socket;
+
+            QList<QTcpDnsServerClient*> m_clients;
+        };
+    }
+}
+
+#endif //QDNSAGG_QTCPDNSSERVER_H

src/modules/dns-server/includes/dns-server/QUdpDnsServer.h

@@ -0,0 +1,37 @@
+//
+// Created by robin on 1/24/18.
+//
+
+#ifndef QDNSAGG_QDNSUDPSERVER_H
+#define QDNSAGG_QDNSUDPSERVER_H
+
+#include <QObject>
+#include <QUdpSocket>
+#include "dns-base/QDnsPacket.h"
+#include "QDnsServer.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+        class QUdpDnsServer : public QDnsServer
+        {
+            Q_OBJECT
+        public:
+            QUdpDnsServer();
+
+        public slots:
+            bool start(const QHostAddress& host, quint16 port) override;
+
+        private slots:
+            void onSocketReadyRead();
+
+            void sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams& answerParams, const QHostAddress& senderAddress, quint16 senderPort);
+
+        private:
+            QUdpSocket* m_socket;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSUDPSERVER_H

src/modules/dns-server/src/QDnsServer.cpp

@@ -0,0 +1,12 @@
+//
+// Created by robin on 1/31/18.
+//
+
+#include "dns-server/QDnsServer.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+    }
+}

src/modules/dns-server/src/QTcpDnsServer.cpp

@@ -0,0 +1,44 @@
+//
+// Created by robin on 1/31/18.
+//
+
+#include <QTcpSocket>
+#include "dns-server/QTcpDnsServer.h"
+#include "QTcpDnsServerClient.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+        QTcpDnsServer::QTcpDnsServer()
+            : m_socket(new QTcpServer(this))
+        {
+            connect(m_socket, &QTcpServer::newConnection, this, &QTcpDnsServer::onNewConnection);
+        }
+
+        bool QTcpDnsServer::start(const QHostAddress &host, quint16 port)
+        {
+            return m_socket->listen(host, port);
+        }
+
+        void QTcpDnsServer::onNewConnection()
+        {
+            auto socket = m_socket->nextPendingConnection();
+            if (socket == nullptr)
+            {
+                return;
+            }
+            auto client = new QTcpDnsServerClient(socket, this);
+            connect(socket, &QTcpSocket::disconnected, [client, this]()
+            {
+                m_clients.removeOne(client);
+                client->deleteLater();
+            });
+            connect(client, &QTcpDnsServerClient::onRequest, [this](QDnsServer::OnRequestParams params)
+            {
+                emit onRequest(params);
+            });
+            m_clients.append(client);
+        }
+    }
+}

src/modules/dns-server/src/QTcpDnsServerClient.cpp

@@ -0,0 +1,69 @@
+//
+// Created by robin on 2/1/18.
+//
+
+#include "QTcpDnsServerClient.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+        QTcpDnsServerClient::QTcpDnsServerClient(QTcpSocket *socket, QObject* parent)
+            : QObject(parent)
+            , m_socket(socket)
+            , m_size(0)
+        {
+            m_socket->setParent(this);
+            connect(m_socket, &QTcpSocket::readyRead, this, &QTcpDnsServerClient::onReadyRead);
+            // TODO implement timeout (~2 mins, RFC 7766)
+        }
+
+        void QTcpDnsServerClient::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams &answerParams)
+        {
+            auto answerRaw = answerParams.answer.serialize(); // TODO split packet if too big (>65535)
+            QByteArray size;
+            QDataStream dataStream(&size, QIODevice::WriteOnly);
+            dataStream << (quint16) answerRaw.size();
+            m_socket->write(size.constData(), size.size());
+            m_socket->write(answerRaw.constData(), answerRaw.size());
+        }
+
+        void QTcpDnsServerClient::onReadyRead()
+        {
+            m_buffer.append(m_socket->readAll());
+
+            bool readAgain;
+
+            do
+            {
+                readAgain = false;
+                if (m_buffer.size() > 2 && m_size == 0)
+                {
+                    QDataStream dataStream(m_buffer);
+                    dataStream >> m_size;
+                }
+                if (m_size != 0 && m_buffer.size() >= m_size + 2)
+                {
+                    auto data = m_buffer.mid(2, m_size);
+                    m_buffer.remove(0, m_size + 2);
+                    m_size = 0;
+                    readAgain = m_buffer.size() != 0;
+                    QDns::Base::QDnsPacket packet(data);
+                    if (packet.isValid())
+                    {
+                        emit onRequest(QDnsServer::OnRequestParams
+                                               {
+                                                       packet,
+                                                       m_socket->peerAddress(),
+                                                       m_socket->peerPort(),
+                                                       [this](QDns::Server::QDnsServer::SendAnswerParams answerParams)
+                                                       {
+                                                           sendAnswer(answerParams);
+                                                       }
+                                               });
+                    }
+                }
+            } while (readAgain);
+        }
+    }
+}

src/modules/dns-server/src/QTcpDnsServerClient.h

@@ -0,0 +1,41 @@
+//
+// Created by robin on 2/1/18.
+//
+
+#ifndef QDNSAGG_QTCPDNSSERVERCLIENT_H
+#define QDNSAGG_QTCPDNSSERVERCLIENT_H
+
+#include <QtCore/QObject>
+#include <QtNetwork/QTcpSocket>
+#include <dns-server/QDnsServer.h>
+
+namespace QDns
+{
+    namespace Server
+    {
+        class QTcpDnsServerClient : public QObject
+        {
+            Q_OBJECT
+        public:
+            explicit QTcpDnsServerClient(QTcpSocket* socket, QObject* parent = nullptr);
+
+        signals:
+            void onRequest(QDnsServer::OnRequestParams params);
+
+        public slots:
+            void sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams& answerParams);
+
+        private slots:
+            void onReadyRead();
+
+        private:
+            QTcpSocket* m_socket;
+
+            QByteArray m_buffer;
+
+            quint16 m_size;
+        };
+    }
+}
+
+#endif //QDNSAGG_QTCPDNSSERVERCLIENT_H

src/modules/dns-server/src/QUdpDnsServer.cpp

@@ -0,0 +1,56 @@
+//
+// Created by robin on 1/24/18.
+//
+
+#include "dns-server/QUdpDnsServer.h"
+
+namespace QDns
+{
+    namespace Server
+    {
+        QUdpDnsServer::QUdpDnsServer()
+            : m_socket(new QUdpSocket(this))
+        {
+            connect(m_socket, &QUdpSocket::readyRead, this, &QUdpDnsServer::onSocketReadyRead);
+        }
+
+        bool QUdpDnsServer::start(const QHostAddress &host, quint16 port)
+        {
+            return m_socket->bind(host, port);
+        }
+
+        void QUdpDnsServer::onSocketReadyRead()
+        {
+            while (m_socket->hasPendingDatagrams())
+            {
+                QByteArray datagram;
+                datagram.resize(m_socket->pendingDatagramSize());
+                QHostAddress senderAddress;
+                quint16 senderPort;
+
+                m_socket->readDatagram(datagram.data(), datagram.size(), &senderAddress, &senderPort);
+                QDns::Base::QDnsPacket packet(datagram);
+                if (packet.isValid())
+                {
+                    emit onRequest(OnRequestParams
+                                           {
+                                                   packet,
+                                                   senderAddress,
+                                                   senderPort,
+                                                   [this, senderAddress, senderPort](QDns::Server::QDnsServer::SendAnswerParams answerParams)
+                                                   {
+                                                       sendAnswer(answerParams, senderAddress, senderPort);
+                                                   }
+                                           });
+                }
+            }
+        }
+
+        void QUdpDnsServer::sendAnswer(const QDns::Server::QDnsServer::SendAnswerParams& answerParams,
+                                       const QHostAddress& senderAddress, quint16 senderPort)
+        {
+            auto answerRaw = answerParams.answer.serialize(); // TODO split packet if too big
+            m_socket->writeDatagram(answerRaw, senderAddress, senderPort);
+        }
+    }
+}

src/modules/dns-server/tests/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-dns-server-tests)
+
+add_executable(${PROJECT_NAME}
+        main.cpp
+        UdpDnsServer.cpp
+        TcpDnsServer.cpp
+        serverTests.h)
+
+target_link_libraries(${PROJECT_NAME} gtest pthread qdnsagg-dns-server)
+
+enable_testing()
+add_test(${PROJECT_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME})

src/modules/dns-server/tests/TcpDnsServer.cpp

@@ -0,0 +1,75 @@
+//
+// Created by robin on 1/30/18.
+//
+
+
+#include <gtest/gtest.h>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QTimer>
+#include <QtNetwork/QTcpSocket>
+
+#include "dns-server/QTcpDnsServer.h"
+
+#include "serverTests.h"
+
+struct TcpDnsServerTestParams
+{
+    QList<const char*> hexData;
+};
+
+class TcpDnsServerTest : public ::testing::TestWithParam<TcpDnsServerTestParams>
+{
+};
+
+TEST_P(TcpDnsServerTest, simple)
+{
+    auto params = GetParam();
+    QCoreApplication app(m_argc, m_argv);
+
+    QTimer timer;
+    QObject::connect(&timer, &QTimer::timeout, qApp, &QCoreApplication::quit);
+    timer.start(1000);
+
+    QDns::Server::QTcpDnsServer server;
+    ASSERT_TRUE(server.start(QHostAddress("127.0.0.1"), 5053));
+    QList<QDns::Base::QDnsPacket> packets;
+    QObject::connect(&server, &QDns::Server::QDnsServer::onRequest, [&packets](QDns::Server::QDnsServer::OnRequestParams params)
+    {
+        packets.append(params.packet);
+    });
+    QList<QDns::Base::QDnsPacket> expectedPackets;
+    QTcpSocket socket;
+    socket.connectToHost(QHostAddress("127.0.0.1"), 5053);
+    socket.waitForConnected();
+    for (auto hexData : params.hexData)
+    {
+        auto data = QByteArray::fromHex(hexData);
+        QByteArray size;
+        QDataStream dataStream(&size, QIODevice::WriteOnly);
+        dataStream << (quint16) data.size();
+        socket.write(size.constData(), size.size());
+        socket.write(data.constData(), data.length());
+        QDns::Base::QDnsPacket packet(data);
+        if (packet.isValid())
+        {
+            expectedPackets.append(packet);
+        }
+    }
+    socket.disconnectFromHost();
+    socket.waitForDisconnected();
+
+    ASSERT_EQ(app.exec(), 0);
+    ASSERT_EQ(packets.size(), expectedPackets.size());
+}
+
+INSTANTIATE_TEST_CASE_P(TcpDnsServerTestInst,
+                        TcpDnsServerTest,
+                        ::testing::Values(
+                                TcpDnsServerTestParams
+                                        {
+                                                QList<const char*>()
+                                                        << "e1bc010000010000000000000266720000010001"
+                                                        << "00"
+                                                        << "e1bc010000010000000000000266720000010001"
+                                        }
+                        ));

src/modules/dns-server/tests/UdpDnsServer.cpp

@@ -0,0 +1,67 @@
+//
+// Created by robin on 1/30/18.
+//
+
+
+#include <gtest/gtest.h>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QTimer>
+
+#include "dns-server/QUdpDnsServer.h"
+
+#include "serverTests.h"
+
+struct UdpDnsServerTestParams
+{
+    QList<const char*> hexData;
+};
+
+class UdpDnsServerTest : public ::testing::TestWithParam<UdpDnsServerTestParams>
+{
+};
+
+TEST_P(UdpDnsServerTest, simple)
+{
+    auto params = GetParam();
+    QCoreApplication app(m_argc, m_argv);
+
+    QTimer timer;
+    QObject::connect(&timer, &QTimer::timeout, qApp, &QCoreApplication::quit);
+    timer.start(1000);
+
+    QDns::Server::QUdpDnsServer server;
+    ASSERT_TRUE(server.start(QHostAddress("127.0.0.1"), 5053));
+    QList<QDns::Base::QDnsPacket> packets;
+    QObject::connect(&server, &QDns::Server::QDnsServer::onRequest, [&packets](QDns::Server::QDnsServer::OnRequestParams params)
+    {
+        packets.append(params.packet);
+    });
+    QList<QDns::Base::QDnsPacket> expectedPackets;
+    QUdpSocket socket;
+    socket.connectToHost(QHostAddress("127.0.0.1"), 5053);
+    for (auto hexData : params.hexData)
+    {
+        auto data = QByteArray::fromHex(hexData);
+        socket.write(data.constData(), data.length());
+        QDns::Base::QDnsPacket packet(data);
+        if (packet.isValid())
+        {
+            expectedPackets.append(packet);
+        }
+    }
+
+    ASSERT_EQ(app.exec(), 0);
+    ASSERT_EQ(packets.size(), expectedPackets.size());
+}
+
+INSTANTIATE_TEST_CASE_P(UdpDnsServerTestInst,
+                        UdpDnsServerTest,
+                        ::testing::Values(
+                                UdpDnsServerTestParams
+                                        {
+                                                QList<const char*>()
+                                                        << "e1bc010000010000000000000266720000010001"
+                                                        << "00"
+                                                        << "e1bc010000010000000000000266720000010001"
+                                        }
+                        ));

src/modules/dns-server/tests/main.cpp

@@ -0,0 +1,14 @@
+#include <gtest/gtest.h>
+
+#include "serverTests.h"
+
+int m_argc;
+char** m_argv;
+
+int main(int argc, char* argv[])
+{
+    m_argc = argc;
+    m_argv = argv;
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/modules/dns-server/tests/serverTests.h

@@ -0,0 +1,11 @@
+//
+// Created by robin on 1/30/18.
+//
+
+#ifndef QDNSAGG_SERVERTESTS_H
+#define QDNSAGG_SERVERTESTS_H
+
+extern int m_argc;
+extern char** m_argv;
+
+#endif //QDNSAGG_SERVERTESTS_H