Added base record data and raw/A

src/modules/dns-base/CMakeLists.txt

 set(CMAKE_CXX_STANDARD 17)
 
 find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
 
 add_library(${PROJECT_NAME}
         src/QDnsHeader.cpp
         src/QDnsPacket.cpp
         includes/dns-base/QDnsPacket.h
         includes/dns-base/QDnsBase.h
-        src/RecordData/QDnsRDataDecoder.cpp
-        includes/dns-base/RecordData/QDnsRDataDecoder.h src/RecordData/QDnsRDataA.cpp includes/dns-base/RecordData/QDnsRDataA.h)
+        src/RecordData/QDnsRecordData.cpp
+        includes/dns-base/RecordData/QDnsRecordData.h
+        src/RecordData/QDnsRecordDataA.cpp
+        includes/dns-base/RecordData/QDnsRecordDataA.h
+        src/RecordData/QDnsRecordDataRaw.cpp
+        includes/dns-base/RecordData/QDnsRecordDataRaw.h)
 
-target_link_libraries(${PROJECT_NAME} Qt5::Core)
+target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network)
 
 find_package(GTest)
 if (GTEST_FOUND)

src/modules/dns-base/includes/dns-base/QDnsResourceRecord.h

 #include <qplatformdefs.h>
 #include <QByteArray>
 #include <QDataStream>
+#include "dns-base/RecordData/QDnsRecordData.h"
 
 namespace QDns
 {
 
             QDnsResourceRecord(const QByteArray &packetData, QDataStream &dataStream);
 
+            QDnsResourceRecord(const QDnsResourceRecord& other);
+
+            QDnsResourceRecord & operator=(const QDnsResourceRecord& other);
+
             virtual ~QDnsResourceRecord() = default;
 
             QByteArray serialize() const;
 
             void setTtl(quint32 ttl);
 
-            const QByteArray &getData() const;
+            QDnsRecordData* getData() const;
 
-            void setData(const QByteArray &data);
+            void setData(QDnsRecordData* data);
 
         private:
+            void copy(const QDnsResourceRecord& other);
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 
             bool m_isValid;
             quint16 m_type;
             quint16 m_class;
             quint32 m_ttl;
-            QByteArray m_data;
+            QScopedPointer<QDnsRecordData> m_data;
         };
     }
 }

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

+//
+// Created by robin on 1/12/18.
+//
+
+#ifndef QDNSAGG_QDNSRECORDDATADECODER_H
+#define QDNSAGG_QDNSRECORDDATADECODER_H
+
+#include <QByteArray>
+
+namespace QDns
+{
+    namespace Base
+    {
+        class QDnsRecordData
+        {
+        public:
+            QDnsRecordData();
+
+            virtual ~QDnsRecordData() = default;
+
+            virtual QByteArray serialize() const = 0;
+
+            virtual void serialize(QDataStream &dataStream) const = 0;
+
+            bool isValid() const;
+
+            virtual QDnsRecordData* clone() const = 0;
+
+        protected:
+            bool m_isValid;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSRECORDDATADECODER_H

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

+//
+// Created by robin on 1/12/18.
+//
+
+#ifndef QDNSAGG_QDNSRDATAA_H
+#define QDNSAGG_QDNSRDATAA_H
+
+#include <qplatformdefs.h>
+#include <QByteArray>
+#include <QDataStream>
+#include <QHostAddress>
+
+#include "QDnsRecordData.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+        class QDnsRecordDataA : public QDnsRecordData
+        {
+        public:
+            QDnsRecordDataA();
+
+            QDnsRecordDataA(const QByteArray &packetData, quint32 pos);
+
+            QDnsRecordDataA(const QByteArray &packetData, QDataStream &dataStream);
+
+            QByteArray serialize() const override;
+
+            void serialize(QDataStream &dataStream) const override;
+
+            virtual QDnsRecordData* clone() const override;
+
+            const QHostAddress &getIp() const;
+
+            void setIp(const QHostAddress &ip);
+
+        private:
+            void parse(const QByteArray &packetData, QDataStream &dataStream);
+
+            QHostAddress m_ip;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSRDATAA_H

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

+//
+// Created by robin on 1/14/18.
+//
+
+#ifndef QDNSAGG_QDNSRECORDDATARAW_H
+#define QDNSAGG_QDNSRECORDDATARAW_H
+
+#include "QDnsRecordData.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+        class QDnsRecordDataRaw : public QDnsRecordData
+        {
+        public:
+            QDnsRecordDataRaw();
+
+            QDnsRecordDataRaw(const QByteArray &packetData, quint32 pos);
+
+            QDnsRecordDataRaw(const QByteArray &packetData, QDataStream &dataStream);
+
+            QByteArray serialize() const override;
+
+            void serialize(QDataStream &dataStream) const override;
+
+            virtual QDnsRecordData* clone() const override;
+
+            const QByteArray &getData() const;
+
+            void setData(const QByteArray &data);
+
+        private:
+            void parse(const QByteArray &packetData, QDataStream &dataStream);
+
+            QByteArray m_data;
+        };
+    }
+}
+
+#endif //QDNSAGG_QDNSRECORDDATARAW_H

src/modules/dns-base/src/QDnsResourceRecord.cpp

 // Created by robin on 1/10/18.
 //
 
+#include "dns-base/RecordData/QDnsRecordDataRaw.h"
 #include "dns-base/QDnsLabel.h"
 #include "dns-base/QDnsResourceRecord.h"
 
     {
         QDnsResourceRecord::QDnsResourceRecord()
                 : m_isValid(true)
+                , m_data(0)
         {
         }
 
             parse(packetData, dataStream);
         }
 
+        QDnsResourceRecord::QDnsResourceRecord(const QDnsResourceRecord &other)
+        {
+            copy(other);
+        }
+
+        QDnsResourceRecord &QDnsResourceRecord::operator=(const QDnsResourceRecord& other)
+        {
+            copy(other);
+            return *this;
+        }
+
+        void QDnsResourceRecord::copy(const QDnsResourceRecord &other)
+        {
+            m_isValid = other.m_isValid;
+            m_name = other.m_name;
+            m_type = other.m_type;
+            m_class = other.m_class;
+            m_ttl = other.m_ttl;
+            m_data.reset(other.getData()->clone());
+        }
+
         void QDnsResourceRecord::parse(const QByteArray &packetData, QDataStream &dataStream)
         {
             m_name = QDnsLabel::parse(packetData, dataStream);
                 {
                     char data[length];
                     dataStream.readRawData(data, length);
-                    m_data.append(data, length);
+                    QByteArray byteArray(data, length);
+                    QDataStream dataStream2(byteArray);
+                    m_data.reset(new QDnsRecordDataRaw(packetData, dataStream2));
                 }
             }
         }
             dataStream << m_type;
             dataStream << m_class;
             dataStream << m_ttl;
-            dataStream << (quint16) m_data.length();
-            dataStream.writeRawData(m_data.constData(), m_data.length());
+            QByteArray byteArray;
+            QDataStream dataStream2(&byteArray, QIODevice::WriteOnly);
+            m_data->serialize(dataStream2);
+            dataStream << (quint16) byteArray.length();
+            dataStream.writeRawData(byteArray.constData(), byteArray.length());
         }
 
         bool QDnsResourceRecord::isValid() const
             m_ttl = ttl;
         }
 
-        const QByteArray &QDnsResourceRecord::getData() const
+        QDnsRecordData* QDnsResourceRecord::getData() const
         {
-            return m_data;
+            return m_data.data();
         }
 
-        void QDnsResourceRecord::setData(const QByteArray &data)
+        void QDnsResourceRecord::setData(QDnsRecordData* data)
         {
-            m_data = data;
+            m_data.reset(data);
         }
     }
 }

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

+//
+// Created by robin on 1/12/18.
+//
+
+#include "dns-base/RecordData/QDnsRecordData.h"
+
+
+namespace QDns
+{
+    namespace Base
+    {
+        QDnsRecordData::QDnsRecordData()
+            : m_isValid(true)
+        {
+        }
+
+        bool QDnsRecordData::isValid() const
+        {
+            return m_isValid;
+        }
+    }
+}

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

+//
+// Created by robin on 1/12/18.
+//
+
+#include "dns-base/RecordData/QDnsRecordDataA.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+        QDnsRecordDataA::QDnsRecordDataA()
+            : QDnsRecordData()
+        {
+        }
+
+        QDnsRecordDataA::QDnsRecordDataA(const QByteArray &packetData, quint32 pos)
+            : QDnsRecordDataA()
+        {
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            parse(packetData, dataStream);
+        }
+
+        QDnsRecordDataA::QDnsRecordDataA(const QByteArray &packetData, QDataStream &dataStream)
+            : QDnsRecordDataA()
+        {
+            parse(packetData, dataStream);
+        }
+
+        void QDnsRecordDataA::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            if (dataStream.device()->bytesAvailable() < 4)
+            {
+                m_isValid = false;
+            }
+            else
+            {
+                quint32 ip;
+                dataStream >> ip;
+                m_ip.setAddress(ip);
+            }
+        }
+
+        QByteArray QDnsRecordDataA::serialize() const
+        {
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
+        }
+
+        void QDnsRecordDataA::serialize(QDataStream &dataStream) const
+        {
+            dataStream << m_ip.toIPv4Address();
+        }
+
+        QDnsRecordData *QDnsRecordDataA::clone() const
+        {
+            auto data = new QDnsRecordDataA();
+            data->m_isValid = m_isValid;
+            data->m_ip = m_ip;
+            return nullptr;
+        }
+
+        const QHostAddress &QDnsRecordDataA::getIp() const
+        {
+            return m_ip;
+        }
+
+        void QDnsRecordDataA::setIp(const QHostAddress &ip)
+        {
+            m_ip = ip;
+        }
+    }
+}

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

+//
+// Created by robin on 1/14/18.
+//
+
+#include <QIODevice>
+#include <QDataStream>
+#include "dns-base/RecordData/QDnsRecordDataRaw.h"
+
+namespace QDns
+{
+    namespace Base
+    {
+
+        QDnsRecordDataRaw::QDnsRecordDataRaw()
+            : QDnsRecordData()
+        {
+        }
+
+        QDnsRecordDataRaw::QDnsRecordDataRaw(const QByteArray &packetData, quint32 pos)
+        {
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            parse(packetData, dataStream);
+        }
+
+        QDnsRecordDataRaw::QDnsRecordDataRaw(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            parse(packetData, dataStream);
+        }
+
+        QByteArray QDnsRecordDataRaw::serialize() const
+        {
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
+        }
+
+        void QDnsRecordDataRaw::serialize(QDataStream &dataStream) const
+        {
+            dataStream.writeRawData(m_data.constData(), m_data.length());
+        }
+
+        QDnsRecordData *QDnsRecordDataRaw::clone() const
+        {
+            auto data = new QDnsRecordDataRaw();
+            data->m_isValid = m_isValid;
+            data->m_data = m_data;
+            return data;
+        }
+
+        void QDnsRecordDataRaw::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            while (!dataStream.atEnd())
+            {
+                char data[128];
+                auto read = dataStream.readRawData(data, sizeof(data));
+                m_data.append(data, read);
+            }
+        }
+
+        const QByteArray &QDnsRecordDataRaw::getData() const
+        {
+            return m_data;
+        }
+
+        void QDnsRecordDataRaw::setData(const QByteArray &data)
+        {
+            m_data = data;
+        }
+    }
+}

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

         DnsLabel.cpp
         DnsQuery.cpp
         DnsResourceRecord.cpp
-        DnsPacket.cpp)
+        DnsPacket.cpp
+        RecordData/DnsRDataA.cpp)
 
 target_link_libraries(${PROJECT_NAME} gtest pthread qdnsagg-dns-base)
 

src/modules/dns-base/tests/DnsResourceRecord.cpp

 #include <QString>
 
 #include "dns-base/QDnsResourceRecord.h"
+#include "dns-base/RecordData/QDnsRecordDataRaw.h"
 
 struct DnsResourceRecordParseTestParams
 {
          ASSERT_EQ(rr.getType(), params.type);
          ASSERT_EQ(rr.getClass(), params.clazz);
          ASSERT_EQ(rr.getTtl(), params.ttl);
-         ASSERT_EQ(rr.getData().toHex(), QString(params.hexData2).remove(" "));
+         ASSERT_EQ(rr.getData()->serialize().toHex(), QString(params.hexData2).remove(" "));
     }
 }
 
     rr.setType(params.type);
     rr.setClass(params.clazz);
     rr.setTtl(params.ttl);
-    rr.setData(QByteArray::fromHex(params.hexData2));
+
+    auto data = new QDns::Base::QDnsRecordDataRaw();
+    data->setData(QByteArray::fromHex(params.hexData2));
+    rr.setData(data);
 
     ASSERT_EQ(rr.serialize().toHex(), QString(params.hexData).remove(" "));
 }

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

+//
+// Created by robin on 1/14/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+#include <QtNetwork/QHostAddress>
+#include <dns-base/RecordData/QDnsRecordDataA.h>
+
+struct DnsRDataATestParams
+{
+    bool isValid;
+    const char* hexData;
+    quint32 pos;
+
+    quint32 ip;
+};
+
+class DnsRDataATest : public ::testing::TestWithParam<DnsRDataATestParams>
+{
+};
+
+TEST_P(DnsRDataATest, parseAndGetters)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto rdata = QDns::Base::QDnsRecordDataA(data, params.pos);
+    ASSERT_EQ(rdata.isValid(), params.isValid);
+    
+    if (rdata.isValid())
+    {
+        ASSERT_EQ(rdata.getIp().toIPv4Address(), params.ip);
+        
+        ASSERT_EQ(rdata.serialize().toHex(), QString(params.hexData).remove(" "));
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsRDataATestInst,
+                        DnsRDataATest,
+                        ::testing::Values(
+                                DnsRDataATestParams {false, "", 0},
+                                DnsRDataATestParams {false, "00", 0},
+                                DnsRDataATestParams {true, "acd913e3", 0, QHostAddress("172.217.19.227").toIPv4Address()},
+                                DnsRDataATestParams {true, "d83ad3a3", 0, QHostAddress("216.58.211.163").toIPv4Address()}
+                        ));