Added DnsQuery and associated tests; modified DnsLabel to use QDataStream

src/modules/dns/CMakeLists.txt

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

src/modules/dns/includes/dns/QDnsLabel.h

@@ -15,7 +15,8 @@ namespace QDns
     public:
         QDnsLabel() = delete;
 
-        static QString parse(const QByteArray& data, quint32 pos, quint8 maxRecursion = 5);
+        static QString parse(const QByteArray& packetData, quint32 pos, quint8 maxRecursion = 5);
+        static QString parse(const QByteArray& packetData, QDataStream& dataStream, quint8 maxRecursion = 5);
     };
 
 }

src/modules/dns/includes/dns/QDnsQuery.h

@@ -0,0 +1,43 @@
+//
+// Created by robin on 1/8/18.
+//
+
+#ifndef QDNSAGG_QDNSQUERY_H
+#define QDNSAGG_QDNSQUERY_H
+
+#include <qplatformdefs.h>
+#include <QString>
+
+namespace QDns
+{
+
+    class QDnsQuery
+    {
+    public:
+        QDnsQuery();
+
+        static QDnsQuery parse(const QByteArray& packetData, quint32 pos);
+        QByteArray serialize(const QByteArray& data) 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);
+
+    private:
+        bool m_isValid;
+
+        QString m_name;
+        quint16 m_type;
+        quint16 m_class;
+    };
+
+}
+
+#endif //QDNSAGG_QDNSQUERY_H

src/modules/dns/src/QDnsLabel.cpp

@@ -8,7 +8,14 @@
 namespace QDns
 {
 
-    QString QDnsLabel::parse(const QByteArray& data, quint32 pos, quint8 maxRecursion)
+    QString QDnsLabel::parse(const QByteArray& packetData, quint32 pos, quint8 maxRecursion)
+    {
+        QDataStream dataStream(packetData);
+        dataStream.skipRawData(pos);
+        return parse(packetData, dataStream, maxRecursion);
+    }
+
+    QString QDnsLabel::parse(const QByteArray& packetData, QDataStream& dataStream, quint8 maxRecursion)
     {
         if (maxRecursion == 0)
         {
@@ -16,8 +23,6 @@ namespace QDns
         }
 
         QString fullLabel = "";
-        QDataStream dataStream(data);
-        dataStream.skipRawData(pos);
 
         if (dataStream.device()->bytesAvailable() < 1)
         {
@@ -37,7 +42,9 @@ namespace QDns
                 quint8 labelSize2;
                 dataStream >> labelSize2;
                 quint16 pointer = ((labelSize << 8) | labelSize2) - (quint16) 49152;
-                auto labelEnd = parse(data, pointer, maxRecursion - (quint8) 1);
+                QDataStream dataStream2(packetData);
+                dataStream2.skipRawData(pointer);
+                auto labelEnd = parse(packetData, dataStream2, maxRecursion - (quint8) 1);
                 if (labelEnd.isNull())
                 {
                     return QString::null;

src/modules/dns/src/QDnsQuery.cpp

@@ -0,0 +1,88 @@
+//
+// Created by robin on 1/8/18.
+//
+
+#include <QDataStream>
+#include <includes/dns/QDnsLabel.h>
+#include "dns/QDnsQuery.h"
+
+namespace QDns
+{
+
+    QDnsQuery::QDnsQuery()
+        : m_isValid(true)
+        , m_type(0)
+        , m_class(0)
+    {
+    }
+
+    QDnsQuery QDnsQuery::parse(const QByteArray& packetData, quint32 pos)
+    {
+        QDnsQuery query;
+        QDataStream dataStream(packetData);
+        dataStream.skipRawData(pos);
+
+        if (dataStream.device()->bytesAvailable() < 5)
+        {
+            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;
+            }
+
+        }
+        return query;
+    }
+
+    QByteArray QDnsQuery::serialize(const QByteArray& data) const // TODO
+    {
+        QByteArray byteArray;
+        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+
+        return byteArray;
+    }
+
+    bool QDnsQuery::isValid() const
+    {
+        return m_isValid;
+    }
+
+    const QString& QDnsQuery::getName() const
+    {
+        return m_name;
+    }
+
+    void QDnsQuery::setName(const QString& name)
+    {
+        m_name = name;
+    }
+
+    quint16 QDnsQuery::getType() const
+    {
+        return m_type;
+    }
+
+    void QDnsQuery::setType(quint16 type)
+    {
+        m_type = type;
+    }
+
+    quint16 QDnsQuery::getClass() const
+    {
+        return m_class;
+    }
+
+    void QDnsQuery::setClass(quint16 aClass)
+    {
+        m_class = aClass;
+    }
+}

tests/CMakeLists.txt

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

tests/DnsQuery.cpp

@@ -0,0 +1,67 @@
+//
+// Created by robin on 1/9/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+
+#include "dns/QDnsQuery.h"
+
+struct DnsQueryTestParams
+{
+    bool isValid;
+    const char* hexData;
+    quint32 pos;
+    const char* label;
+    quint16 type;
+    quint16 clazz;
+};
+
+class DnsQueryTest : public ::testing::TestWithParam<DnsQueryTestParams>
+{
+};
+
+TEST_P(DnsQueryTest, parse)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto query = QDns::QDnsQuery::parse(data, params.pos);
+
+    ASSERT_EQ(query.isValid(), params.isValid);
+
+    if (query.isValid())
+    {
+         ASSERT_STREQ(query.getName().toStdString().c_str(), params.label);
+         ASSERT_EQ(query.getType(), params.type);
+         ASSERT_EQ(query.getClass(), params.clazz);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsQueryTestInst,
+                        DnsQueryTest,
+                        ::testing::Values(
+                                DnsQueryTestParams {false, "", 0},
+                                DnsQueryTestParams {false, "00", 0},
+                                DnsQueryTestParams {true,
+                                                    "0377777706676f6f676c650266720000010001",
+                                                    0,
+                                                    "www.google.fr",
+                                                    1,
+                                                    1
+                                },
+                                DnsQueryTestParams {true,
+                                                    "03777777067274686f6e6903636f6d0000030008",
+                                                    0,
+                                                    "www.rthoni.com",
+                                                    3,
+                                                    8
+                                },
+                                DnsQueryTestParams {true,
+                                                    "0003777777067274686f6e6903636f6d0000030008",
+                                                    1,
+                                                    "www.rthoni.com",
+                                                    3,
+                                                    8
+                                }
+                        ));