Added TCP and UDP clients

src/modules/dns-client/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-dns-client)
+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/QDnsClient.cpp includes/dns-client/QDnsClient.h src/QDnsUdpClient.cpp includes/dns-client/QDnsUdpClient.h src/QDnsTcpClient.cpp includes/dns-client/QDnsTcpClient.h)
+
+target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network qdnsagg-dns-base)
+
+find_package(GTest)
+if (GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

src/modules/dns-client/includes/dns-client/QDnsClient.h

@@ -0,0 +1,115 @@
+//
+// Created by robin on 2/2/18.
+//
+
+#ifndef QDNSAGG_QDNSCLIENT_H
+#define QDNSAGG_QDNSCLIENT_H
+
+#include <QObject>
+#include <QHostAddress>
+#include "dns-base/QDnsPacket.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        class QDnsClient : public QObject
+        {
+            Q_OBJECT
+        public:
+            enum ClientState
+            {
+                Disconnected = 0,
+                Connecting = 1,
+                Connected = 2,
+                Disconnecting = 3
+            };
+
+            enum ErrorCode
+            {
+                Unknown = 0,
+                Timeout = 1,
+                InvalidData = 2,
+                UnknownId = 3,
+                NotAnswer = 4,
+                SocketError = 5,
+                NotConnected = 6
+            };
+
+            struct OnStateChangedParams
+            {
+                quint64 reserved;
+                ClientState state;
+            };
+
+            struct OnAnswerParams
+            {
+                quint64 reserved;
+                QDns::Base::QDnsPacket query;
+                QDns::Base::QDnsPacket answer;
+                QHostAddress host;
+                quint16 port;
+            };
+
+            struct OnErrorParams
+            {
+                quint64 reserved;
+                ErrorCode error;
+                QAbstractSocket::SocketError socketError;
+                QDns::Base::QDnsPacket query;
+                QByteArray data;
+                QDns::Base::QDnsPacket answer;
+                QHostAddress host;
+                quint16 port;
+            };
+
+            explicit QDnsClient(const QHostAddress& host, quint16 port = 53);
+
+            const QHostAddress &getHost() const;
+
+            quint16 getPort() const;
+
+            quint32 getQueryTimeout() const;
+
+            void setQueryTimeout(quint32 queryTimeout);
+
+            ClientState getState() const;
+
+        signals:
+            void onStateChanged(OnStateChangedParams params);
+            void onAnswer(OnAnswerParams params);
+            void onError(OnErrorParams params);
+
+        public slots:
+            virtual void connectToHost() = 0;
+            virtual void query(QDns::Base::QDnsPacket packet);
+            virtual void disconnectFromHost() = 0;
+
+        protected:
+            struct ProcessDataParams
+            {
+                QByteArray data;
+                QHostAddress senderAddress;
+                quint16 senderPort;
+            };
+
+            virtual void doQuery(QDns::Base::QDnsPacket packet) = 0;
+
+            void processData(ProcessDataParams params);
+
+            void setState(ClientState state);
+
+            QHostAddress m_host;
+
+            quint16 m_port;
+
+            quint32 m_queryTimeout;
+
+            QMap<quint16, QDns::Base::QDnsPacket> m_pendingQueries;
+
+            ClientState m_state;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSCLIENT_H

src/modules/dns-client/includes/dns-client/QDnsTcpClient.h

@@ -0,0 +1,43 @@
+//
+// Created by robin on 2/7/18.
+//
+
+#ifndef QDNSAGG_QDNSTCPCLIENT_H
+#define QDNSAGG_QDNSTCPCLIENT_H
+
+#include <QtNetwork/QTcpSocket>
+#include "QDnsClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        class QDnsTcpClient : public QDnsClient
+        {
+            Q_OBJECT
+        public:
+            explicit QDnsTcpClient(const QHostAddress &host, quint16 port = 53);
+
+        public slots:
+            void connectToHost() override;
+            void disconnectFromHost() override;
+
+        protected:
+            void doQuery(QDns::Base::QDnsPacket packet) override;
+
+        private slots:
+            void onSocketReadyRead();
+            void onSocketStateChanged(QAbstractSocket::SocketState socketState);
+            void onSocketError(QAbstractSocket::SocketError error);
+
+        private:
+            QTcpSocket* m_socket;
+
+            QByteArray m_buffer;
+
+            quint16 m_size;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSTCPCLIENT_H

src/modules/dns-client/includes/dns-client/QDnsUdpClient.h

@@ -0,0 +1,38 @@
+//
+// Created by robin on 2/2/18.
+//
+
+#ifndef QDNSAGG_QDNSUDPCLIENT_H
+#define QDNSAGG_QDNSUDPCLIENT_H
+
+#include <QtNetwork/QUdpSocket>
+#include "QDnsClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        class QDnsUdpClient : public QDnsClient
+        {
+            Q_OBJECT
+        public:
+            explicit QDnsUdpClient(const QHostAddress& host, quint16 port = 53);
+
+        public slots:
+            void connectToHost() override;
+            void disconnectFromHost() override;
+
+        protected:
+            void doQuery(QDns::Base::QDnsPacket packet) override;
+
+        private slots:
+            void onReadyRead();
+            void onSocketError(QAbstractSocket::SocketError error);
+
+        private:
+            QUdpSocket* m_socket;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSUDPCLIENT_H

src/modules/dns-client/src/QDnsClient.cpp

@@ -0,0 +1,166 @@
+//
+// Created by robin on 2/2/18.
+//
+
+#include <QtCore/QTimer>
+#include "dns-client/QDnsClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        QDnsClient::QDnsClient(const QHostAddress &host, quint16 port)
+            : m_host(host)
+            , m_port(port)
+            , m_queryTimeout(5000)
+            , m_state(ClientState::Disconnected)
+        {
+        }
+
+        const QHostAddress &QDnsClient::getHost() const
+        {
+            return m_host;
+        }
+
+        quint16 QDnsClient::getPort() const
+        {
+            return m_port;
+        }
+
+        quint32 QDnsClient::getQueryTimeout() const
+        {
+            return m_queryTimeout;
+        }
+
+        void QDnsClient::setQueryTimeout(quint32 queryTimeout)
+        {
+            m_queryTimeout = queryTimeout;
+        }
+
+        QDnsClient::ClientState QDnsClient::getState() const
+        {
+            return m_state;
+        }
+
+        void QDnsClient::query(QDns::Base::QDnsPacket packet)
+        {
+            if (m_state != ClientState::Connected)
+            {
+                emit onError(OnErrorParams
+                                     {
+                                             0,
+                                             ErrorCode::NotConnected,
+                                             QAbstractSocket::UnknownSocketError,
+                                             QDns::Base::QDnsPacket(""),
+                                             QByteArray(),
+                                             packet,
+                                             m_host,
+                                             m_port
+                                     });
+                return;
+            }
+            if (packet.getHeader().getId() == 0)
+            {
+                auto header = packet.getHeader();
+                header.setId((quint16) qrand());
+                packet.setHeader(header);
+            }
+            m_pendingQueries.insert(packet.getHeader().getId(), packet);
+
+            auto timer = new QTimer(this);
+            connect(timer, &QTimer::timeout, [this, packet]()
+            {
+                if (m_pendingQueries.contains(packet.getHeader().getId()))
+                {
+                    emit onError(OnErrorParams
+                                         {
+                                                 0,
+                                                 ErrorCode::Timeout,
+                                                 QAbstractSocket::UnknownSocketError,
+                                                 packet,
+                                                 QByteArray(),
+                                                 QDns::Base::QDnsPacket(""),
+                                                 m_host,
+                                                 m_port
+                                         });
+                }
+            });
+            timer->setSingleShot(true);
+            timer->start(m_queryTimeout);
+
+            doQuery(packet);
+        }
+
+        void QDnsClient::processData(QDnsClient::ProcessDataParams params)
+        {
+            QDns::Base::QDnsPacket packet(params.data);
+            if (packet.isValid())
+            {
+                ErrorCode error = ErrorCode::Unknown;
+                QDns::Base::QDnsPacket query("");
+                if (!m_pendingQueries.contains(packet.getHeader().getId()))
+                {
+                    error = ErrorCode::UnknownId;
+                }
+                else
+                {
+                    query = m_pendingQueries[packet.getHeader().getId()];
+                    m_pendingQueries.remove(packet.getHeader().getId());
+                }
+                if (packet.getHeader().isQuery())
+                {
+                    error = ErrorCode::NotAnswer;
+                }
+                if (error == ErrorCode::Unknown)
+                {
+                    emit onAnswer(OnAnswerParams
+                                          {
+                                                  0,
+                                                  query,
+                                                  packet,
+                                                  params.senderAddress,
+                                                  params.senderPort
+                                          });
+                }
+                else
+                {
+                    emit onError(OnErrorParams
+                                         {
+                                                 0,
+                                                 error,
+                                                 QAbstractSocket::UnknownSocketError,
+                                                 query,
+                                                 params.data,
+                                                 packet,
+                                                 params.senderAddress,
+                                                 params.senderPort
+                                         });
+                }
+            }
+            else
+            {
+                emit onError(OnErrorParams
+                                     {
+                                             0,
+                                             ErrorCode::InvalidData,
+                                             QAbstractSocket::UnknownSocketError,
+                                             QDns::Base::QDnsPacket(""),
+                                             params.data,
+                                             QDns::Base::QDnsPacket(""),
+                                             params.senderAddress,
+                                             params.senderPort
+                                     });
+            }
+        }
+
+        void QDnsClient::setState(QDnsClient::ClientState state)
+        {
+            m_state = state;
+            emit onStateChanged(OnStateChangedParams
+                                        {
+                                                0,
+                                                m_state
+                                        });
+        }
+    }
+}

src/modules/dns-client/src/QDnsTcpClient.cpp

@@ -0,0 +1,106 @@
+//
+// Created by robin on 2/7/18.
+//
+
+#include "dns-client/QDnsTcpClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        QDnsTcpClient::QDnsTcpClient(const QHostAddress &host, quint16 port)
+            : QDnsClient(host, port)
+            , m_socket(new QTcpSocket(this))
+            , m_size(0)
+        {
+            connect(m_socket, &QTcpSocket::readyRead, this, &QDnsTcpClient::onSocketReadyRead);
+            connect(m_socket, &QTcpSocket::stateChanged, this, &QDnsTcpClient::onSocketStateChanged);
+            connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
+        }
+
+        void QDnsTcpClient::connectToHost()
+        {
+            m_socket->connectToHost(m_host, m_port);
+        }
+
+        void QDnsTcpClient::disconnectFromHost()
+        {
+            m_socket->disconnectFromHost();
+        }
+
+        void QDnsTcpClient::doQuery(QDns::Base::QDnsPacket packet)
+        {
+            auto answerRaw = packet.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 QDnsTcpClient::onSocketReadyRead()
+        {
+            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;
+                    processData(ProcessDataParams
+                                        {
+                                                data,
+                                                m_socket->peerAddress(),
+                                                m_socket->peerPort()
+                                        });
+                }
+            } while (readAgain);
+        }
+
+        void QDnsTcpClient::onSocketStateChanged(QAbstractSocket::SocketState socketState)
+        {
+            if (socketState == QAbstractSocket::SocketState::HostLookupState)
+            {
+                setState(ClientState::Connecting);
+            }
+            else if (socketState == QAbstractSocket::SocketState::ConnectedState)
+            {
+                setState(ClientState::Connected);
+            }
+            else if (socketState == QAbstractSocket::SocketState::ClosingState)
+            {
+                setState(ClientState::Disconnecting);
+            }
+            else if (socketState == QAbstractSocket::SocketState::UnconnectedState)
+            {
+                setState(ClientState::Disconnected);
+            }
+        }
+
+        void QDnsTcpClient::onSocketError(QAbstractSocket::SocketError error)
+        {
+            emit onError(OnErrorParams
+                                 {
+                                         0,
+                                         SocketError,
+                                         error,
+                                         QDns::Base::QDnsPacket(""),
+                                         QByteArray(),
+                                         QDns::Base::QDnsPacket(""),
+                                         m_host,
+                                         m_port
+                                 });
+        }
+    }
+}

src/modules/dns-client/src/QDnsUdpClient.cpp

@@ -0,0 +1,70 @@
+//
+// Created by robin on 2/2/18.
+//
+
+#include "dns-client/QDnsUdpClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        QDnsUdpClient::QDnsUdpClient(const QHostAddress &host, quint16 port)
+            : QDnsClient(host, port)
+            , m_socket(new QUdpSocket(this))
+        {
+            connect(m_socket, &QUdpSocket::readyRead, this, &QDnsUdpClient::onReadyRead);
+            connect(m_socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
+        }
+
+        void QDnsUdpClient::connectToHost()
+        {
+            setState(ClientState::Connecting);
+            setState(ClientState::Connected);
+        }
+
+        void QDnsUdpClient::disconnectFromHost()
+        {
+            setState(ClientState::Disconnecting);
+            setState(ClientState::Disconnected);
+        }
+
+        void QDnsUdpClient::doQuery(QDns::Base::QDnsPacket packet)
+        {
+            m_socket->writeDatagram(packet.serialize(), m_host, m_port);
+        }
+
+        void QDnsUdpClient::onReadyRead()
+        {
+            while (m_socket->hasPendingDatagrams())
+            {
+                QByteArray datagram;
+                datagram.resize((int) m_socket->pendingDatagramSize());
+                QHostAddress senderAddress;
+                quint16 senderPort;
+
+                m_socket->readDatagram(datagram.data(), datagram.size(), &senderAddress, &senderPort); // TODO check sender and port? May not answer from same ip?
+                processData(ProcessDataParams
+                                    {
+                                            datagram,
+                                            senderAddress,
+                                            senderPort
+                                    });
+            }
+        }
+
+        void QDnsUdpClient::onSocketError(QAbstractSocket::SocketError error)
+        {
+            emit onError(OnErrorParams
+                                 {
+                                         0,
+                                         SocketError,
+                                         error,
+                                         QDns::Base::QDnsPacket(""),
+                                         QByteArray(),
+                                         QDns::Base::QDnsPacket(""),
+                                         m_host,
+                                         m_port
+                                 });
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-dns-client-tests)
+
+add_executable(${PROJECT_NAME}
+        main.cpp)
+
+target_link_libraries(${PROJECT_NAME} gtest pthread qdnsagg-dns-client)
+
+enable_testing()
+add_test(${PROJECT_NAME} ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME})

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

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