Added QDnsAxfrClient

src/modules/dns-client/CMakeLists.txt

@@ -12,7 +12,14 @@ 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)
+        src/QDnsClient.cpp
+        includes/dns-client/QDnsClient.h
+        src/QDnsUdpClient.cpp
+        includes/dns-client/QDnsUdpClient.h
+        src/QDnsTcpClient.cpp
+        includes/dns-client/QDnsTcpClient.h
+        src/QDnsAxfrClient.cpp
+        includes/dns-client/QDnsAxfrClient.h)
 
 target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network qdnsagg-dns-base)
 

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

@@ -0,0 +1,83 @@
+//
+// Created by robin on 2/12/18.
+//
+
+#ifndef QDNSAGG_QDNSAXFRCLIENT_H
+#define QDNSAGG_QDNSAXFRCLIENT_H
+
+#include <QObject>
+#include <QHostAddress>
+#include "QDnsUdpClient.h"
+#include "QDnsTcpClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        class QDnsAxfrClient : public QObject
+        {
+        Q_OBJECT
+        public:
+            enum ErrorCode
+            {
+                Unknown = 0,
+                ClientError = 1,
+                NoFirstSOA = 2,
+                NoLastSOA = 3,
+                ExtraRecords = 4
+            };
+            Q_ENUM(ErrorCode)
+
+            struct OnAnswerParams
+            {
+                quint64 reserved;
+                QList<QDns::Base::QDnsResourceRecord> records;
+            };
+
+            struct OnErrorParams
+            {
+                quint64 reserved;
+                ErrorCode error;
+                QDnsClient::OnErrorParams clientError;
+            };
+
+            explicit QDnsAxfrClient(const QString& zone, const QHostAddress& host, quint16 port = 53, QObject* parent = nullptr);
+
+        signals:
+            void onAnswer(OnAnswerParams);
+            void onError(OnErrorParams);
+
+        public slots:
+            void transfer();
+
+        private slots:
+            void onClientStateChanged(const QDnsClient::OnStateChangedParams& params);
+
+            void onClientAnswer(const QDnsClient::OnAnswerParams& params);
+
+            void onClientError(const QDnsClient::OnErrorParams& params);
+
+        private:
+            enum AxfrStatus
+            {
+                FirstSOA,
+                Records,
+                LastSOA
+            };
+
+            void processPacket(const QDns::Base::QDnsPacket& packet);
+
+            QString m_zone;
+
+            AxfrStatus m_status;
+
+            QDns::Client::QDnsUdpClient* m_udpClient;
+
+            QDns::Client::QDnsTcpClient* m_tcpClient;
+
+            QList<QDns::Base::QDnsResourceRecord> m_records;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSAXFRCLIENT_H

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

@@ -0,0 +1,114 @@
+//
+// Created by robin on 2/12/18.
+//
+
+#include "dns-client/QDnsAxfrClient.h"
+
+namespace QDns
+{
+    namespace Client
+    {
+        QDnsAxfrClient::QDnsAxfrClient(const QString& zone, const QHostAddress& host, quint16 port, QObject *parent)
+                : QObject(parent)
+                , m_zone(zone)
+                , m_status(AxfrStatus::FirstSOA)
+                , m_udpClient(new QDns::Client::QDnsUdpClient(host, port, this))
+                , m_tcpClient(new QDns::Client::QDnsTcpClient(host, port, this))
+        {
+            connect(m_udpClient, &QDnsClient::onStateChanged, this, &QDnsAxfrClient::onClientStateChanged);
+            connect(m_tcpClient, &QDnsClient::onStateChanged, this, &QDnsAxfrClient::onClientStateChanged);
+            connect(m_udpClient, &QDnsClient::onAnswer, this, &QDnsAxfrClient::onClientAnswer);
+            connect(m_tcpClient, &QDnsClient::onAnswer, this, &QDnsAxfrClient::onClientAnswer);
+            connect(m_udpClient, &QDnsClient::onError, this, &QDnsAxfrClient::onClientError);
+            connect(m_tcpClient, &QDnsClient::onError, this, &QDnsAxfrClient::onClientError);
+        }
+
+        void QDnsAxfrClient::transfer()
+        {
+            m_status = AxfrStatus::FirstSOA;
+            m_records.clear();
+            m_udpClient->connectToHost();
+            m_tcpClient->connectToHost();
+        }
+
+        void QDnsAxfrClient::onClientStateChanged(const QDnsClient::OnStateChangedParams& params)
+        {
+            if (m_udpClient->getState() == QDnsClient::ClientState::Connected
+                && m_tcpClient->getState() == QDnsClient::ClientState::Connected)
+            {
+                auto axfrQuery = QDns::Base::QDnsPacket::makeSimpleQuery(m_zone, QDns::Base::QDnsBase::RecordType::AXFR);
+                m_tcpClient->query(axfrQuery);
+            }
+        }
+
+        void QDnsAxfrClient::onClientAnswer(const QDnsClient::OnAnswerParams& params)
+        {
+            processPacket(params.answer);
+        }
+
+        void QDnsAxfrClient::onClientError(const QDnsClient::OnErrorParams &params)
+        {
+            if (params.error == QDns::Client::QDnsClient::ErrorCode::UnknownId)
+            {
+                processPacket(params.answer);
+            }
+            else
+            {
+                emit onError(OnErrorParams
+                                     {
+                                             0,
+                                             ErrorCode::ClientError,
+                                             params
+                                     });
+            }
+        }
+
+        void QDnsAxfrClient::processPacket(const QDns::Base::QDnsPacket& packet)
+        {
+            if (m_status == AxfrStatus::FirstSOA)
+            {
+                if (packet.getHeader().getAnswerCount() == 1 &&
+                    packet.getAnswerRecords().first().getType() == QDns::Base::QDnsBase::RecordType::SOA)
+                {
+                    m_status = AxfrStatus::Records;
+                    m_records.append(packet.getAnswerRecords());
+                }
+                else
+                {
+                    emit onError(OnErrorParams
+                                         {
+                                                 0,
+                                                 ErrorCode::NoFirstSOA
+                                         });
+                }
+            }
+            else if (m_status == AxfrStatus::Records)
+            {
+                if (packet.getHeader().getAnswerCount() == 1 &&
+                    packet.getAnswerRecords().first().getType() == QDns::Base::QDnsBase::RecordType::SOA)
+                {
+                    m_status = AxfrStatus::LastSOA;
+                    m_udpClient->disconnectFromHost();
+                    m_tcpClient->disconnectFromHost();
+                    emit onAnswer(OnAnswerParams
+                                          {
+                                                  0,
+                                                  m_records
+                                          });
+                }
+                else
+                {
+                    m_records.append(packet.getAnswerRecords());
+                }
+            }
+            else
+            {
+                emit onError(OnErrorParams
+                                     {
+                                             0,
+                                             ErrorCode::ExtraRecords
+                                     });
+            }
+        }
+    }
+}