Added SOA record data

src/modules/dns-base/CMakeLists.txt

@@ -30,7 +30,7 @@ add_library(${PROJECT_NAME}
         src/RecordData/QDnsRecordDataRaw.cpp
         includes/dns-base/RecordData/QDnsRecordDataRaw.h
         src/RecordData/QDnsRecordDataAAAA.cpp
-        includes/dns-base/RecordData/QDnsRecordDataAAAA.h src/RecordData/QDnsRecordDataMX.cpp includes/dns-base/RecordData/QDnsRecordDataMX.h)
+        includes/dns-base/RecordData/QDnsRecordDataAAAA.h src/RecordData/QDnsRecordDataMX.cpp includes/dns-base/RecordData/QDnsRecordDataMX.h src/RecordData/QDnsRecordDataSOA.cpp includes/dns-base/RecordData/QDnsRecordDataSOA.h)
 
 target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network)
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataSOA.h

@@ -0,0 +1,83 @@
+//
+// Created by robin on 1/23/18.
+//
+
+#ifndef QDNSAGG_QDNSRECORDDATASOA_H
+#define QDNSAGG_QDNSRECORDDATASOA_H
+
+#include <qplatformdefs.h>
+#include <QByteArray>
+#include <QDataStream>
+#include <QHostAddress>
+
+#include "QDnsRecordData.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+        class QDnsRecordDataSOA : public QDnsRecordData
+        {
+        public:
+            QDnsRecordDataSOA();
+
+            QDnsRecordDataSOA(const QByteArray &packetData, quint32 pos);
+
+            QDnsRecordDataSOA(const QByteArray &packetData, QDataStream &dataStream);
+
+            QByteArray serialize() const override;
+
+            void serialize(QDataStream &dataStream) const override;
+
+            virtual QDnsRecordData* clone() const override;
+
+            const QString &getPrimaryNs() const;
+
+            void setPrimaryNs(const QString &primaryNs);
+
+            const QString &getAdminMb() const;
+
+            void setAdminMb(const QString &adminMb);
+
+            quint32 getSerialNumber() const;
+
+            void setSerialNumber(quint32 serialNumber);
+
+            quint32 getRefreshInterval() const;
+
+            void setRefreshInterval(quint32 refreshInterval);
+
+            quint32 getRetryInterval() const;
+
+            void setRetryInterval(quint32 retryInterval);
+
+            quint32 getExpirationLimit() const;
+
+            void setExpirationLimit(quint32 expirationLimit);
+
+            quint32 getMinimumTtl() const;
+
+            void setMinimumTtl(quint32 minimumTtl);
+
+        private:
+            void parse(const QByteArray &packetData, QDataStream &dataStream);
+
+            QString m_primaryNs;
+
+            QString m_adminMb;
+
+            quint32 m_serialNumber;
+
+            quint32 m_refreshInterval;
+
+            quint32 m_retryInterval;
+
+            quint32 m_expirationLimit;
+
+            quint32 m_minimumTtl;
+        };
+    }
+}
+
+
+#endif //QDNSAGG_QDNSRECORDDATASOA_H

src/modules/dns-base/src/RecordData/QDnsRecordDataSOA.cpp

@@ -0,0 +1,166 @@
+//
+// Created by robin on 1/23/18.
+//
+
+#include "dns-base/QDnsLabel.h"
+#include "dns-base/RecordData/QDnsRecordDataSOA.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+        QDnsRecordDataSOA::QDnsRecordDataSOA()
+                : QDnsRecordData()
+        {
+        }
+
+        QDnsRecordDataSOA::QDnsRecordDataSOA(const QByteArray &packetData, quint32 pos)
+                : QDnsRecordDataSOA()
+        {
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            parse(packetData, dataStream);
+        }
+
+        QDnsRecordDataSOA::QDnsRecordDataSOA(const QByteArray &packetData, QDataStream &dataStream)
+                : QDnsRecordDataSOA()
+        {
+            parse(packetData, dataStream);
+        }
+
+        void QDnsRecordDataSOA::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            if (dataStream.device()->bytesAvailable() < 22)
+            {
+                m_isValid = false;
+            }
+            else
+            {
+                m_primaryNs = QDnsLabel::parse(packetData, dataStream);
+                if (m_primaryNs.isNull())
+                {
+                    m_isValid = false;
+                }
+                else
+                {
+                    m_adminMb = QDnsLabel::parse(packetData, dataStream);
+                    if (m_adminMb.isNull())
+                    {
+                        m_isValid = false;
+                    }
+                    else
+                    {
+                        dataStream >> m_serialNumber;
+                        dataStream >> m_refreshInterval;
+                        dataStream >> m_retryInterval;
+                        dataStream >> m_expirationLimit;
+                        dataStream >> m_minimumTtl;
+                    }
+                }
+            }
+        }
+
+        QByteArray QDnsRecordDataSOA::serialize() const
+        {
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
+        }
+
+        void QDnsRecordDataSOA::serialize(QDataStream &dataStream) const
+        {
+            QDnsLabel::serialize(m_primaryNs, dataStream);
+            QDnsLabel::serialize(m_adminMb, dataStream);
+            dataStream << m_serialNumber;
+            dataStream << m_refreshInterval;
+            dataStream << m_retryInterval;
+            dataStream << m_expirationLimit;
+            dataStream << m_minimumTtl;
+        }
+
+        QDnsRecordData *QDnsRecordDataSOA::clone() const
+        {
+            auto data = new QDnsRecordDataSOA();
+            data->m_isValid = m_isValid;
+            data->m_primaryNs = m_primaryNs;
+            data->m_adminMb = m_adminMb;
+            data->m_serialNumber = m_serialNumber;
+            data->m_refreshInterval = m_refreshInterval;
+            data->m_retryInterval = m_retryInterval;
+            data->m_expirationLimit = m_expirationLimit;
+            data->m_minimumTtl = m_minimumTtl;
+            return data;
+        }
+
+        const QString &QDnsRecordDataSOA::getPrimaryNs() const
+        {
+            return m_primaryNs;
+        }
+
+        void QDnsRecordDataSOA::setPrimaryNs(const QString &primaryNs)
+        {
+            m_primaryNs = primaryNs;
+        }
+
+        const QString &QDnsRecordDataSOA::getAdminMb() const
+        {
+            return m_adminMb;
+        }
+
+        void QDnsRecordDataSOA::setAdminMb(const QString &adminMb)
+        {
+            m_adminMb = adminMb;
+        }
+
+        quint32 QDnsRecordDataSOA::getSerialNumber() const
+        {
+            return m_serialNumber;
+        }
+
+        void QDnsRecordDataSOA::setSerialNumber(quint32 serialNumber)
+        {
+            m_serialNumber = serialNumber;
+        }
+
+        quint32 QDnsRecordDataSOA::getRefreshInterval() const
+        {
+            return m_refreshInterval;
+        }
+
+        void QDnsRecordDataSOA::setRefreshInterval(quint32 refreshInterval)
+        {
+            m_refreshInterval = refreshInterval;
+        }
+
+        quint32 QDnsRecordDataSOA::getRetryInterval() const
+        {
+            return m_retryInterval;
+        }
+
+        void QDnsRecordDataSOA::setRetryInterval(quint32 retryInterval)
+        {
+            m_retryInterval = retryInterval;
+        }
+
+        quint32 QDnsRecordDataSOA::getExpirationLimit() const
+        {
+            return m_expirationLimit;
+        }
+
+        void QDnsRecordDataSOA::setExpirationLimit(quint32 expirationLimit)
+        {
+            m_expirationLimit = expirationLimit;
+        }
+
+        quint32 QDnsRecordDataSOA::getMinimumTtl() const
+        {
+            return m_minimumTtl;
+        }
+
+        void QDnsRecordDataSOA::setMinimumTtl(quint32 minimumTtl)
+        {
+            m_minimumTtl = minimumTtl;
+        }
+    }
+}

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

@@ -10,7 +10,8 @@ add_executable(${PROJECT_NAME}
         DnsPacket.cpp
         RecordData/DnsRDataA.cpp
         RecordData/DnsRDataAAAA.cpp
-        RecordData/DnsRDataMX.cpp)
+        RecordData/DnsRDataMX.cpp
+        RecordData/DnsRDataSOA.cpp)
 
 target_link_libraries(${PROJECT_NAME} gtest pthread qdnsagg-dns-base)
 

src/modules/dns-base/tests/RecordData/DnsRDataSOA.cpp

@@ -0,0 +1,57 @@
+//
+// Created by robin on 1/14/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+#include <QtNetwork/QHostAddress>
+#include <dns-base/RecordData/QDnsRecordDataSOA.h>
+
+struct DnsRDataSOATestParams
+{
+    bool isValid;
+    const char* hexData;
+    quint32 pos;
+
+    QString primaryNs;
+    QString adminMb;
+    quint32 serialNumber;
+    quint32 refreshInterval;
+    quint32 retryInterval;
+    quint32 expirationLimit;
+    quint32 minimumTtl;
+};
+
+class DnsRDataSOATest : public ::testing::TestWithParam<DnsRDataSOATestParams>
+{
+};
+
+TEST_P(DnsRDataSOATest, parseAndGetters)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto rdata = QDns::Base::QDnsRecordDataSOA(data, params.pos);
+    ASSERT_EQ(rdata.isValid(), params.isValid);
+
+    if (rdata.isValid())
+    {
+        ASSERT_EQ(params.primaryNs, rdata.getPrimaryNs());
+        ASSERT_EQ(params.adminMb, rdata.getAdminMb());
+        ASSERT_EQ(params.serialNumber, rdata.getSerialNumber());
+        ASSERT_EQ(params.refreshInterval, rdata.getRefreshInterval());
+        ASSERT_EQ(params.retryInterval, rdata.getRetryInterval());
+        ASSERT_EQ(params.expirationLimit, rdata.getExpirationLimit());
+        ASSERT_EQ(params.minimumTtl, rdata.getMinimumTtl());
+
+        ASSERT_EQ(rdata.serialize().toHex(), QString(params.hexData).remove(" "));
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsRDataSOATestInst,
+                        DnsRDataSOATest,
+                        ::testing::Values(
+                                DnsRDataSOATestParams {false, "", 0},
+                                DnsRDataSOATestParams {false, "00", 0},
+                                DnsRDataSOATestParams {true, "036e733106676f6f676c6503636f6d0009646e732d61646d696e06676f6f676c6503636f6d000ae6ef6f0000038400000384000007080000003c", 0, "ns1.google.com", "dns-admin.google.com", 182906735, 900, 900, 1800, 60}
+                        ));