Added DnsPacket and associated tests

src/modules/dns/CMakeLists.txt

@@ -12,6 +12,8 @@ add_library(qdnsagg-dns
         includes/dns/QDnsQuery.h
         src/QDnsResourceRecord.cpp
         includes/dns/QDnsResourceRecord.h
+        src/QDnsPacket.cpp
+        includes/dns/QDnsPacket.h
         )
 
 target_link_libraries(qdnsagg-dns Qt5::Core Qt5::Network)

src/modules/dns/includes/dns/QDnsPacket.h

@@ -0,0 +1,61 @@
+//
+// Created by robin on 1/8/18.
+//
+
+#ifndef QDNSAGG_QDNSPACKET_H
+#define QDNSAGG_QDNSPACKET_H
+
+#include <QByteArray>
+#include "QDnsHeader.h"
+#include "QDnsQuery.h"
+#include "QDnsResourceRecord.h"
+
+namespace QDns
+{
+
+    class QDnsPacket
+    {
+    public:
+        QDnsPacket();
+
+        static QDnsPacket parse(const QByteArray& data);
+        static QDnsPacket parse(const QByteArray& data, QDataStream& dataStream);
+        QByteArray serialize() const;
+        void serialize(QDataStream& dataStream) const;
+
+        bool isValid() const;
+
+        const QDnsHeader& getHeader() const;
+
+        void setHeader(const QDnsHeader& header);
+
+        const QList<QDnsQuery>& getQueries() const;
+
+        void setQueries(const QList<QDnsQuery>& queries);
+
+        const QList<QDnsResourceRecord>& getAnswerRecords() const;
+
+        void setAnswerRecords(const QList<QDnsResourceRecord>& answerRecords);
+
+        const QList<QDnsResourceRecord>& getAuthorityRecords() const;
+
+        void setAuthorityRecords(const QList<QDnsResourceRecord>& authorityRecords);
+
+        const QList<QDnsResourceRecord>& getAdditionalRecords() const;
+
+        void setAdditionalRecords(const QList<QDnsResourceRecord>& additionalRecords);
+
+    private:
+        bool m_isValid;
+
+        QDnsHeader m_header;
+
+        QList<QDnsQuery> m_queries;
+        QList<QDnsResourceRecord> m_answerRecords;
+        QList<QDnsResourceRecord> m_authorityRecords;
+        QList<QDnsResourceRecord> m_additionalRecords;
+    };
+
+}
+
+#endif //QDNSAGG_QDNSPACKET_H

src/modules/dns/src/QDnsPacket.cpp

@@ -0,0 +1,165 @@
+//
+// Created by robin on 1/8/18.
+//
+
+#include <QDataStream>
+#include "dns/QDnsPacket.h"
+
+namespace QDns
+{
+
+    QDnsPacket::QDnsPacket()
+        : m_isValid(true)
+    {
+    }
+
+    QDnsPacket QDnsPacket::parse(const QByteArray& data)
+    {
+        QDataStream dataStream(data);
+        return parse(data, dataStream);
+    }
+
+    QDnsPacket QDnsPacket::parse(const QByteArray& data, QDataStream& dataStream)
+    {
+        QDnsPacket packet;
+
+        packet.m_header = QDnsHeader::parse(dataStream);
+        if (!packet.m_header.isValid())
+        {
+            packet.m_isValid = false;
+        }
+        else
+        {
+            for (quint16 i = 0; i < packet.m_header.getQueryCount() && packet.m_isValid; ++i)
+            {
+                auto entry = QDnsQuery::parse(data, dataStream);
+                if (!entry.isValid())
+                {
+                    packet.m_isValid = false;
+                }
+                packet.m_queries.append(entry);
+            }
+            for (quint16 i = 0; i < packet.m_header.getAnswerCount() && packet.m_isValid; ++i)
+            {
+                auto entry = QDnsResourceRecord::parse(data, dataStream);
+                if (!entry.isValid())
+                {
+                    packet.m_isValid = false;
+                }
+                packet.m_answerRecords.append(entry);
+            }
+            for (quint16 i = 0; i < packet.m_header.getAuthorityCount() && packet.m_isValid; ++i)
+            {
+                auto entry = QDnsResourceRecord::parse(data, dataStream);
+                if (!entry.isValid())
+                {
+                    packet.m_isValid = false;
+                }
+                packet.m_authorityRecords.append(entry);
+            }
+            for (quint16 i = 0; i < packet.m_header.getAdditionalCount() && packet.m_isValid; ++i)
+            {
+                auto entry = QDnsResourceRecord::parse(data, dataStream);
+                if (!entry.isValid())
+                {
+                    packet.m_isValid = false;
+                }
+                packet.m_additionalRecords.append(entry);
+            }
+        }
+
+        return packet;
+    }
+
+    QByteArray QDnsPacket::serialize() const
+    {
+        QByteArray byteArray;
+        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+        serialize(dataStream);
+        return byteArray;
+    }
+
+    void QDnsPacket::serialize(QDataStream& dataStream) const
+    {
+        m_header.serialize(dataStream);
+        for (const auto& entry : m_queries)
+        {
+            entry.serialize(dataStream);
+        }
+        for (const auto& entry : m_answerRecords)
+        {
+            entry.serialize(dataStream);
+        }
+        for (const auto& entry : m_authorityRecords)
+        {
+            entry.serialize(dataStream);
+        }
+        for (const auto& entry : m_additionalRecords)
+        {
+            entry.serialize(dataStream);
+        }
+    }
+
+    bool QDnsPacket::isValid() const
+    {
+        return m_isValid;
+    }
+
+    const QDnsHeader& QDnsPacket::getHeader() const
+    {
+        return m_header;
+    }
+
+    void QDnsPacket::setHeader(const QDnsHeader& header)
+    {
+        m_header = header;
+        m_header.setQueryCount((quint16) m_queries.length());
+        m_header.setAnswerCount((quint16) m_answerRecords.length());
+        m_header.setAuthorityCount((quint16) m_authorityRecords.length());
+        m_header.setAdditionalCount((quint16) m_additionalRecords.length());
+    }
+
+    const QList<QDnsQuery>& QDnsPacket::getQueries() const
+    {
+        return m_queries;
+    }
+
+    void QDnsPacket::setQueries(const QList<QDnsQuery>& queries)
+    {
+        m_queries = queries;
+        m_header.setQueryCount((quint16) m_queries.length());
+    }
+
+    const QList<QDnsResourceRecord>& QDnsPacket::getAnswerRecords() const
+    {
+        return m_answerRecords;
+    }
+
+    void QDnsPacket::setAnswerRecords(const QList<QDnsResourceRecord>& answerRecords)
+    {
+        m_answerRecords = answerRecords;
+        m_header.setAnswerCount((quint16) m_answerRecords.length());
+    }
+
+    const QList<QDnsResourceRecord>& QDnsPacket::getAuthorityRecords() const
+    {
+        return m_authorityRecords;
+    }
+
+    void QDnsPacket::setAuthorityRecords(const QList<QDnsResourceRecord>& authorityRecords)
+    {
+        m_authorityRecords = authorityRecords;
+        m_header.setAuthorityCount((quint16) m_authorityRecords.length());
+    }
+
+    const QList<QDnsResourceRecord>& QDnsPacket::getAdditionalRecords() const
+    {
+        return m_additionalRecords;
+    }
+
+    void QDnsPacket::setAdditionalRecords(const QList<QDnsResourceRecord>& additionalRecords)
+    {
+        m_additionalRecords = additionalRecords;
+        m_header.setAdditionalCount((quint16) m_additionalRecords.length());
+    }
+}

tests/CMakeLists.txt

@@ -10,7 +10,8 @@ add_executable(qdnsagg-tests
         DnsHeader.cpp
         DnsLabel.cpp
         DnsQuery.cpp
-        DnsResourceRecord.cpp)
+        DnsResourceRecord.cpp
+        DnsPacket.cpp)
 
 target_link_libraries(qdnsagg-tests gtest pthread qdnsagg-dns)
 add_test(qdnsagg-tests ${CMAKE_CURRENT_BINARY_DIR}/qdnsagg-tests)

tests/DnsPacket.cpp

@@ -0,0 +1,80 @@
+//
+// Created by robin on 1/10/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+
+#include "dns/QDnsPacket.h"
+
+struct DnsPacketParseTestParams
+{
+    bool isValid;
+    const char* hexData;
+};
+
+class DnsPacketParseTest : public ::testing::TestWithParam<DnsPacketParseTestParams>
+{
+};
+
+TEST_P(DnsPacketParseTest, parse)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto packet = QDns::QDnsPacket::parse(data);
+
+    ASSERT_EQ(packet.isValid(), params.isValid);
+
+    if (packet.isValid())
+    {
+        // TODO improve tests
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsPacketParseTestInst,
+                        DnsPacketParseTest,
+                        ::testing::Values(
+                                DnsPacketParseTestParams {false, ""},
+                                DnsPacketParseTestParams {true, "1c588580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d"},
+                                DnsPacketParseTestParams {true, "1c580100000100000000000003777777067274686f6e6903636f6d0000010001"},
+                                DnsPacketParseTestParams {true, "42c3818000010001000000000377777706676f6f676c650266720000010001c00c000100010000012c0004d83ad3a3"},
+                                DnsPacketParseTestParams {true, "42c3010000010000000000000377777706676f6f676c650266720000010001"},
+                                DnsPacketParseTestParams {true, "07298180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd913e3"},
+                                DnsPacketParseTestParams {true, "07290100000100000000000006676f6f676c650266720000010001"},
+                                DnsPacketParseTestParams {true, "e1bc818000010000000100000266720000010001c00c0006000100000e100030086e736d6173746572036e6963c00c0a686f73746d6173746572c029849e46cf00000e10000007080036ee8000001518"},
+                                DnsPacketParseTestParams {true, "e1bc010000010000000000000266720000010001"}
+                        ));
+
+struct DnsPacketSerializeTestParams
+{
+    const char* hexData1;
+    const char* hexData2;
+};
+
+class DnsPacketSerializeTest : public ::testing::TestWithParam<DnsPacketSerializeTestParams>
+{
+};
+
+TEST_P(DnsPacketSerializeTest, parse)
+{
+    auto params = GetParam();
+    auto data1 = QByteArray::fromHex(params.hexData1);
+    auto packet = QDns::QDnsPacket::parse(data1);
+
+    // TODO improve tests
+    ASSERT_EQ(packet.serialize().toHex(), QString(params.hexData2).remove(" "));
+}
+
+INSTANTIATE_TEST_CASE_P(DnsPacketSerializeTestInst,
+                        DnsPacketSerializeTest,
+                        ::testing::Values(
+                                DnsPacketSerializeTestParams {
+                                        "07290100000100000000000006676f6f676c650266720000010001",
+                                        "07290100000100000000000006676f6f676c650266720000010001"
+                                },
+                                DnsPacketSerializeTestParams {
+                                        "1c588580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                        "1c588580000100020000000003777777067274686f6e6903636f6d000001000103777777067274686f6e6903636f6d0000050001000002580008057365727633c010057365727633067274686f6e6903636f6d0000010001000002580004d5f6343d"
+                                }
+                        ));