Added DnsResourceRecord and associated tests; code cleaning

src/modules/dns/CMakeLists.txt

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

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

@@ -0,0 +1,59 @@
+//
+// Created by robin on 1/10/18.
+//
+
+#ifndef QDNSAGG_RESOURCERECORD_H
+#define QDNSAGG_RESOURCERECORD_H
+
+#include <qplatformdefs.h>
+#include <QByteArray>
+#include <QDataStream>
+
+namespace QDns
+{
+
+    class QDnsResourceRecord
+    {
+    public:
+        QDnsResourceRecord();
+
+        static QDnsResourceRecord parse(const QByteArray& packetData, quint32 pos);
+        static QDnsResourceRecord parse(const QByteArray& packetData, QDataStream& dataStream);
+        QByteArray serialize() const;
+        void serialize(QDataStream& dataStream) const;
+
+        bool isValid() const;
+
+        const QString& getName() const;
+
+        void setName(const QString& name);
+
+        quint16 getType() const;
+
+        void setType(quint16 type);
+
+        quint16 getClass() const;
+
+        void setClass(quint16 aClass);
+
+        quint32 getTtl() const;
+
+        void setTtl(quint32 ttl);
+
+        const QByteArray& getData() const;
+
+        void setData(const QByteArray& data);
+
+    private:
+        bool m_isValid;
+
+        QString m_name;
+        quint16 m_type;
+        quint16 m_class;
+        quint32 m_ttl;
+        QByteArray m_data;
+    };
+
+}
+
+#endif //QDNSAGG_RESOURCERECORD_H

src/modules/dns/src/QDnsQuery.cpp

@@ -27,24 +27,17 @@ namespace QDns
     {
         QDnsQuery query;
 
-        if (dataStream.device()->bytesAvailable() < 5)
+        query.m_name = QDnsLabel::parse(packetData, dataStream);
+        if (query.m_name.isNull() || dataStream.device()->bytesAvailable() < 4)
         {
             query.m_isValid = false;
         }
         else
         {
-            query.m_name = QDnsLabel::parse(packetData, dataStream);
-            if (query.m_name.isNull() || dataStream.device()->bytesAvailable() < 4)
-            {
-                query.m_isValid = false;
-            }
-            else
-            {
-                dataStream >> query.m_type;
-                dataStream >> query.m_class;
-            }
-
+            dataStream >> query.m_type;
+            dataStream >> query.m_class;
         }
+
         return query;
     }
 
@@ -58,8 +51,7 @@ namespace QDns
 
     void QDnsQuery::serialize(QDataStream& dataStream) const
     {
-        auto label = QDnsLabel::serialize(m_name);
-        dataStream.writeRawData(label.constData(), label.length());
+        QDnsLabel::serialize(m_name, dataStream);
         dataStream << m_type;
         dataStream << m_class;
     }

src/modules/dns/src/QDnsResourceRecord.cpp

@@ -0,0 +1,126 @@
+//
+// Created by robin on 1/10/18.
+//
+
+#include "dns/QDnsLabel.h"
+#include "dns/QDnsResourceRecord.h"
+
+namespace QDns
+{
+
+    QDnsResourceRecord::QDnsResourceRecord()
+        : m_isValid(true)
+    {
+    }
+
+    QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray& packetData, quint32 pos)
+    {
+        QDataStream dataStream(packetData);
+        dataStream.skipRawData(pos);
+        return parse(packetData, dataStream);
+    }
+
+    QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray& packetData, QDataStream& dataStream)
+    {
+        QDnsResourceRecord rr;
+
+        rr.m_name = QDnsLabel::parse(packetData, dataStream);
+        if (rr.m_name.isNull() || dataStream.device()->bytesAvailable() < 10)
+        {
+            rr.m_isValid = false;
+        }
+        else
+        {
+            dataStream >> rr.m_type;
+            dataStream >> rr.m_class;
+            dataStream >> rr.m_ttl;
+            quint16 length;
+            dataStream >> length;
+            if (dataStream.device()->bytesAvailable() < length)
+            {
+                rr.m_isValid = false;
+            }
+            else
+            {
+                char data[length];
+                dataStream.readRawData(data, length);
+                rr.m_data.append(data, length);
+            }
+        }
+        return rr;
+    }
+
+    QByteArray QDnsResourceRecord::serialize() const
+    {
+        QByteArray byteArray;
+        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+        serialize(dataStream);
+        return byteArray;
+    }
+
+    void QDnsResourceRecord::serialize(QDataStream& dataStream) const
+    {
+        auto label = QDnsLabel::serialize(m_name);
+        dataStream.writeRawData(label.constData(), label.length());
+        dataStream << m_type;
+        dataStream << m_class;
+        dataStream << m_ttl;
+        dataStream << (quint16) m_data.length();
+        dataStream.writeRawData(m_data.constData(), m_data.length());
+    }
+
+    bool QDnsResourceRecord::isValid() const
+    {
+        return m_isValid;
+    }
+
+    const QString& QDnsResourceRecord::getName() const
+    {
+        return m_name;
+    }
+
+    void QDnsResourceRecord::setName(const QString& name)
+    {
+        m_name = name;
+    }
+
+    quint16 QDnsResourceRecord::getType() const
+    {
+        return m_type;
+    }
+
+    void QDnsResourceRecord::setType(quint16 type)
+    {
+        m_type = type;
+    }
+
+    quint16 QDnsResourceRecord::getClass() const
+    {
+        return m_class;
+    }
+
+    void QDnsResourceRecord::setClass(quint16 aClass)
+    {
+        m_class = aClass;
+    }
+
+    quint32 QDnsResourceRecord::getTtl() const
+    {
+        return m_ttl;
+    }
+
+    void QDnsResourceRecord::setTtl(quint32 ttl)
+    {
+        m_ttl = ttl;
+    }
+
+    const QByteArray& QDnsResourceRecord::getData() const
+    {
+        return m_data;
+    }
+
+    void QDnsResourceRecord::setData(const QByteArray& data)
+    {
+        m_data = data;
+    }
+}

tests/CMakeLists.txt

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

tests/DnsLabel.cpp

@@ -42,46 +42,46 @@ INSTANTIATE_TEST_CASE_P(DnsLabelParseTestInst,
                                 DnsLabelParseTestParams {false, "", 0},
                                 DnsLabelParseTestParams {true, "00", 0, ""},
                                 DnsLabelParseTestParams {true,
-                                                    "06676f6f676c6502667200",
-                                                    0,
-                                                    "google.fr"
+                                                         "06676f6f676c6502667200",
+                                                         0,
+                                                         "google.fr"
                                 },
                                 DnsLabelParseTestParams {true,
-                                                    "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
-                                                    12,
-                                                    "google.fr"
+                                                         "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
+                                                         12,
+                                                         "google.fr"
                                 },
                                 DnsLabelParseTestParams {true,
-                                                    "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
-                                                    27,
-                                                    "google.fr"
+                                                         "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
+                                                         27,
+                                                         "google.fr"
                                 },
                                 DnsLabelParseTestParams {true,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
-                                                    12,
-                                                    "www.rthoni.com"
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                         12,
+                                                         "www.rthoni.com"
                                 },
                                 DnsLabelParseTestParams {true,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
-                                                    32,
-                                                    "www.rthoni.com"
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                         32,
+                                                         "www.rthoni.com"
                                 },
                                 DnsLabelParseTestParams {true,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
-                                                    44,
-                                                    "serv3.rthoni.com"
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                         44,
+                                                         "serv3.rthoni.com"
                                 },
                                 DnsLabelParseTestParams {false,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 c02c c02c00010001000002580004d5f6343d",
-                                                    44
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 c02c c02c00010001000002580004d5f6343d",
+                                                         44
                                 },
                                 DnsLabelParseTestParams {false,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 802c c02c00010001000002580004d5f6343d",
-                                                    44
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 802c c02c00010001000002580004d5f6343d",
+                                                         44
                                 },
                                 DnsLabelParseTestParams {false,
-                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 402c c02c00010001000002580004d5f6343d",
-                                                    44
+                                                         "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 402c c02c00010001000002580004d5f6343d",
+                                                         44
                                 }
                         ));
 

tests/DnsQuery.cpp

@@ -84,7 +84,6 @@ class DnsQuerySerializeTest : public ::testing::TestWithParam<DnsQuerySerializeT
 TEST_P(DnsQuerySerializeTest, serialize)
 {
     auto params = GetParam();
-    auto data = QByteArray::fromHex(params.hexData);
     QDns::QDnsQuery query;
 
     query.setName(params.name);

tests/DnsResourceRecord.cpp

@@ -0,0 +1,125 @@
+//
+// Created by robin on 1/9/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+
+#include "dns/QDnsResourceRecord.h"
+
+struct DnsResourceRecordParseTestParams
+{
+    bool isValid;
+    const char* hexData;
+    quint32 pos;
+    const char* label;
+    quint16 type;
+    quint16 clazz;
+    quint32 ttl;
+    const char* hexData2;
+};
+
+class DnsResourceRecordParseTest : public ::testing::TestWithParam<DnsResourceRecordParseTestParams>
+{
+};
+
+TEST_P(DnsResourceRecordParseTest, parse)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto rr = QDns::QDnsResourceRecord::parse(data, params.pos);
+
+    ASSERT_EQ(rr.isValid(), params.isValid);
+
+    if (rr.isValid())
+    {
+         ASSERT_STREQ(rr.getName().toStdString().c_str(), params.label);
+         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(" "));
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsResourceRecordParseTestInst,
+                        DnsResourceRecordParseTest,
+                        ::testing::Values(
+                                DnsResourceRecordParseTestParams {false, "", 0},
+                                DnsResourceRecordParseTestParams {false, "00", 0},
+                                DnsResourceRecordParseTestParams {true,
+                                                                  "e1bc818000010000000100000266720000010001c00c0006000100000e100030086e736d6173746572036e6963c00c0a686f73746d6173746572c029849e46cf00000e10000007080036ee8000001518",
+                                                                  20,
+                                                                  "fr",
+                                                                  6,
+                                                                  1,
+                                                                  3600,
+                                                                  "086e736d6173746572036e6963c00c0a686f73746d6173746572c029849e46cf00000e10000007080036ee8000001518"
+                                },
+                                DnsResourceRecordParseTestParams {true,
+                                                                  "1c588580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                                  32,
+                                                                  "www.rthoni.com",
+                                                                  5,
+                                                                  1,
+                                                                  600,
+                                                                  "057365727633c010"
+                                },
+                                DnsResourceRecordParseTestParams {true,
+                                                                  "1c588580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                                  52,
+                                                                  "serv3.rthoni.com",
+                                                                  1,
+                                                                  1,
+                                                                  600,
+                                                                  "d5f6343d"
+                                }
+                        ));
+
+struct DnsResourceRecordSerializeTestParams
+{
+    const char* hexData;
+
+    const char* name;
+    quint16 type;
+    quint16 clazz;
+    quint32 ttl;
+    const char* hexData2;
+};
+
+class DnsResourceRecordSerializeTest : public ::testing::TestWithParam<DnsResourceRecordSerializeTestParams>
+{
+};
+
+TEST_P(DnsResourceRecordSerializeTest, serialize)
+{
+    auto params = GetParam();
+    QDns::QDnsResourceRecord rr;
+
+    rr.setName(params.name);
+    rr.setType(params.type);
+    rr.setClass(params.clazz);
+    rr.setTtl(params.ttl);
+    rr.setData(QByteArray::fromHex(params.hexData2));
+
+    ASSERT_EQ(rr.serialize().toHex(), QString(params.hexData).remove(" "));
+}
+
+INSTANTIATE_TEST_CASE_P(DnsResourceRecordSerializeTestInst,
+                        DnsResourceRecordSerializeTest,
+                        ::testing::Values(
+                                DnsResourceRecordSerializeTestParams {"026672000006000100000e100030086e736d6173746572036e6963c00c0a686f73746d6173746572c029849e46cf00000e10000007080036ee8000001518",
+                                                                      "fr",
+                                                                      6,
+                                                                      1,
+                                                                      3600,
+                                                                      "086e736d6173746572036e6963c00c0a686f73746d6173746572c029849e46cf00000e10000007080036ee8000001518"
+                                },
+                                DnsResourceRecordSerializeTestParams {"03777777067274686f6e6903636f6d0000050001000002580008057365727633c010",
+                                                                      "www.rthoni.com",
+                                                                      5,
+                                                                      1,
+                                                                      600,
+                                                                      "057365727633c010"
+                                }
+                        ));