Added DnsLabel and associated tests; refactored tests

src/modules/dns/CMakeLists.txt

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

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

@@ -0,0 +1,23 @@
+//
+// Created by robin on 1/9/18.
+//
+
+#ifndef QDNSAGG_QDNSLABEL_H
+#define QDNSAGG_QDNSLABEL_H
+
+#include <QString>
+
+namespace QDns
+{
+
+    class QDnsLabel
+    {
+    public:
+        QDnsLabel() = delete;
+
+        static QString parse(const QByteArray& data, quint32 pos, quint8 maxRecursion = 5);
+    };
+
+}
+
+#endif //QDNSAGG_QDNSLABEL_H

src/modules/dns/src/QDnsLabel.cpp

@@ -0,0 +1,80 @@
+//
+// Created by robin on 1/9/18.
+//
+
+#include "dns/QDnsLabel.h"
+#include <QDataStream>
+
+namespace QDns
+{
+
+    QString QDnsLabel::parse(const QByteArray& data, quint32 pos, quint8 maxRecursion)
+    {
+        if (maxRecursion == 0)
+        {
+            return QString::null;
+        }
+
+        QString fullLabel = "";
+        QDataStream dataStream(data);
+        dataStream.skipRawData(pos);
+
+        if (dataStream.device()->bytesAvailable() < 1)
+        {
+            return QString::null;
+        }
+
+        quint8 labelSize;
+        dataStream >> labelSize;
+        while (labelSize != 0)
+        {
+            if (labelSize >> 6 == 3)
+            {
+                if (dataStream.device()->bytesAvailable() < 1)
+                {
+                    return QString::null;
+                }
+                quint8 labelSize2;
+                dataStream >> labelSize2;
+                quint16 pointer = ((labelSize << 8) | labelSize2) - (quint16) 49152;
+                auto labelEnd = parse(data, pointer, maxRecursion - (quint8) 1);
+                if (labelEnd.isNull())
+                {
+                    return QString::null;
+                }
+                if (!fullLabel.isEmpty())
+                {
+                    fullLabel.append(".");
+                }
+                fullLabel.append(labelEnd);
+                break;
+            }
+            else if (labelSize >> 6 == 0)
+            {
+
+                if (dataStream.device()->bytesAvailable() < labelSize + 1)
+                {
+                    return QString::null;
+                }
+
+                char label[labelSize];
+                int read = dataStream.readRawData(label, labelSize);
+                if (read != labelSize)
+                {
+                    return QString::null;
+                }
+                if (!fullLabel.isEmpty())
+                {
+                    fullLabel.append(".");
+                }
+                fullLabel.append(QByteArray(label, labelSize));
+                dataStream >> labelSize;
+            }
+            else
+            {
+                return QString::null;
+            }
+        }
+        return fullLabel;
+    }
+}

tests/CMakeLists.txt

@@ -7,6 +7,8 @@ include_directories(../src/modules/dns/includes)
 
 add_executable(qdnsagg-tests
         main.cpp
+        DnsHeader.cpp
+        DnsLabel.cpp
         )
 
 target_link_libraries(qdnsagg-tests gtest pthread qdnsagg-dns)

tests/DnsLabel.cpp

@@ -0,0 +1,86 @@
+//
+// Created by robin on 1/9/18.
+//
+
+#include <gtest/gtest.h>
+#include <QByteArray>
+#include <QString>
+
+#include "dns/QDnsLabel.h"
+
+struct DnsLabelTestParams
+{
+    bool isValid;
+    const char* hexData;
+    quint32 pos;
+    const char* label;
+};
+
+class DnsLabelTest : public ::testing::TestWithParam<DnsLabelTestParams>
+{
+};
+
+TEST_P(DnsLabelTest, parse)
+{
+    auto params = GetParam();
+    auto data = QByteArray::fromHex(params.hexData);
+    auto label = QDns::QDnsLabel::parse(data, params.pos);
+    if (params.isValid)
+    {
+        ASSERT_FALSE(label.isNull());
+        ASSERT_STREQ(params.label, label.toStdString().c_str());
+    }
+    else
+    {
+        ASSERT_TRUE(label.isNull());
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(DnsLabelTestInst,
+                        DnsLabelTest,
+                        ::testing::Values(
+                                DnsLabelTestParams {false, "", 0},
+                                DnsLabelTestParams {true, "00", 0, ""},
+                                DnsLabelTestParams {true,
+                                                    "06676f6f676c6502667200",
+                                                    0,
+                                                    "google.fr"
+                                },
+                                DnsLabelTestParams {true,
+                                                    "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
+                                                    12,
+                                                    "google.fr"
+                                },
+                                DnsLabelTestParams {true,
+                                                    "587a8180000100010000000006676f6f676c650266720000010001c00c000100010000012c0004acd912a3",
+                                                    27,
+                                                    "google.fr"
+                                },
+                                DnsLabelTestParams {true,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                    12,
+                                                    "www.rthoni.com"
+                                },
+                                DnsLabelTestParams {true,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                    32,
+                                                    "www.rthoni.com"
+                                },
+                                DnsLabelTestParams {true,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633c010c02c00010001000002580004d5f6343d",
+                                                    44,
+                                                    "serv3.rthoni.com"
+                                },
+                                DnsLabelTestParams {false,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 c02c c02c00010001000002580004d5f6343d",
+                                                    44
+                                },
+                                DnsLabelTestParams {false,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 802c c02c00010001000002580004d5f6343d",
+                                                    44
+                                },
+                                DnsLabelTestParams {false,
+                                                    "3dcd8580000100020000000003777777067274686f6e6903636f6d0000010001c00c00050001000002580008057365727633 402c c02c00010001000002580004d5f6343d",
+                                                    44
+                                }
+                        ));

tests/main.cpp

@@ -1,262 +1,4 @@
 #include <gtest/gtest.h>
-#include <QByteArray>
-#include <QString>
-
-#include "dns/QDnsHeader.h"
-
-struct DNSHeaderTestParams
-{
-    bool isValid;
-    const char* hexData;
-    quint16 id;
-
-    quint16 flags;
-    bool flagQuery;
-    quint8 flagOpcode;
-    bool flagAuthoritative;
-    bool flagTruncated;
-    bool flagRecursionDesired;
-    bool flagRecursionAvailable;
-    bool flagReserved0;
-    bool flagAnswerAuthenticated;
-    bool flagNonAuthenticatedAcceptable;
-    quint8 flagReplyCode;
-
-    quint16 questionCount;
-    quint16 answerCount;
-    quint16 authorityCount;
-    quint16 additionalCount;
-};
-
-class DNSHeaderTest : public ::testing::TestWithParam<DNSHeaderTestParams>
-{
-};
-
-TEST_P(DNSHeaderTest, parseAndGetters)
-{
-    auto params = GetParam();
-    auto data = QByteArray::fromHex(params.hexData);
-    auto header = QDns::QDnsHeader::parse(data);
-    ASSERT_EQ(header.isValid(), params.isValid);
-
-    if (header.isValid())
-    {
-        ASSERT_EQ(header.getId(), params.id);
-
-        ASSERT_EQ(header.getFlags(), params.flags);
-        ASSERT_EQ(header.isQuery(), params.flagQuery);
-        ASSERT_EQ(header.getOpcode(), params.flagOpcode);
-        ASSERT_EQ(header.isAuthoritative(), params.flagAuthoritative);
-        ASSERT_EQ(header.isTruncated(), params.flagTruncated);
-        ASSERT_EQ(header.isRecursionDesired(), params.flagRecursionDesired);
-        ASSERT_EQ(header.isRecursionAvailable(), params.flagRecursionAvailable);
-        ASSERT_EQ(header.isAnswerAuthenticated(), params.flagAnswerAuthenticated);
-        ASSERT_EQ(header.isNonAuthenticatedAcceptable(), params.flagNonAuthenticatedAcceptable);
-        ASSERT_EQ(header.getReplyCode(), params.flagReplyCode);
-
-        ASSERT_EQ(header.getQuestionCount(), params.questionCount);
-        ASSERT_EQ(header.getAnswerCount(), params.answerCount);
-        ASSERT_EQ(header.getAuthorityCount(), params.authorityCount);
-        ASSERT_EQ(header.getAdditionalCount(), params.additionalCount);
-
-        ASSERT_EQ(header.serialize().toHex(), QString(params.hexData).remove(" "));
-    }
-}
-
-TEST_P(DNSHeaderTest, settersAndGetters1)
-{
-    auto params = GetParam();
-
-    if (!params.isValid)
-    {
-        return;
-    }
-
-    auto data = QByteArray::fromHex(params.hexData);
-    QDns::QDnsHeader header;
-
-    header.setId(params.id);
-    header.setFlags(params.flags);
-    header.setQuestionCount(params.questionCount);
-    header.setAnswerCount(params.answerCount);
-    header.setAuthorityCount(params.authorityCount);
-    header.setAdditionalCount(params.additionalCount);
-
-    ASSERT_EQ(header.getId(), params.id);
-
-    ASSERT_EQ(header.getFlags(), params.flags);
-    ASSERT_EQ(header.isQuery(), params.flagQuery);
-    ASSERT_EQ(header.getOpcode(), params.flagOpcode);
-    ASSERT_EQ(header.isAuthoritative(), params.flagAuthoritative);
-    ASSERT_EQ(header.isTruncated(), params.flagTruncated);
-    ASSERT_EQ(header.isRecursionDesired(), params.flagRecursionDesired);
-    ASSERT_EQ(header.isRecursionAvailable(), params.flagRecursionAvailable);
-    ASSERT_EQ(header.isAnswerAuthenticated(), params.flagAnswerAuthenticated);
-    ASSERT_EQ(header.isNonAuthenticatedAcceptable(), params.flagNonAuthenticatedAcceptable);
-    ASSERT_EQ(header.getReplyCode(), params.flagReplyCode);
-
-    ASSERT_EQ(header.getQuestionCount(), params.questionCount);
-    ASSERT_EQ(header.getAnswerCount(), params.answerCount);
-    ASSERT_EQ(header.getAuthorityCount(), params.authorityCount);
-    ASSERT_EQ(header.getAdditionalCount(), params.additionalCount);
-
-    ASSERT_EQ(header.serialize().toHex(), QString(params.hexData).remove(" "));
-}
-
-TEST_P(DNSHeaderTest, settersAndGetters2)
-{
-    auto params = GetParam();
-
-    if (!params.isValid)
-    {
-        return;
-    }
-
-    auto data = QByteArray::fromHex(params.hexData);
-    QDns::QDnsHeader header;
-
-    header.setId(params.id);
-    header.setIsQuery(params.flagQuery);
-    header.setOpcode(params.flagOpcode);
-    header.setIsAuthoritative(params.flagAuthoritative);
-    header.setIsTruncated(params.flagTruncated);
-    header.setIsRecursionDesired(params.flagRecursionDesired);
-    header.setIsRecursionAvailable(params.flagRecursionAvailable);
-    header.setFlagBits(9, (quint16) params.flagReserved0, 1);
-    header.setIsAnswerAuthenticated(params.flagAnswerAuthenticated);
-    header.setNonAuthenticatedAcceptable(params.flagNonAuthenticatedAcceptable);
-    header.setReplyCode(params.flagReplyCode);
-    header.setQuestionCount(params.questionCount);
-    header.setAnswerCount(params.answerCount);
-    header.setAuthorityCount(params.authorityCount);
-    header.setAdditionalCount(params.additionalCount);
-
-    ASSERT_EQ(header.getId(), params.id);
-
-    ASSERT_EQ(header.getFlags(), params.flags);
-    ASSERT_EQ(header.isQuery(), params.flagQuery);
-    ASSERT_EQ(header.getOpcode(), params.flagOpcode);
-    ASSERT_EQ(header.isAuthoritative(), params.flagAuthoritative);
-    ASSERT_EQ(header.isTruncated(), params.flagTruncated);
-    ASSERT_EQ(header.isRecursionDesired(), params.flagRecursionDesired);
-    ASSERT_EQ(header.isRecursionAvailable(), params.flagRecursionAvailable);
-    ASSERT_EQ(header.isAnswerAuthenticated(), params.flagAnswerAuthenticated);
-    ASSERT_EQ(header.isNonAuthenticatedAcceptable(), params.flagNonAuthenticatedAcceptable);
-    ASSERT_EQ(header.getReplyCode(), params.flagReplyCode);
-
-    ASSERT_EQ(header.getQuestionCount(), params.questionCount);
-    ASSERT_EQ(header.getAnswerCount(), params.answerCount);
-    ASSERT_EQ(header.getAuthorityCount(), params.authorityCount);
-    ASSERT_EQ(header.getAdditionalCount(), params.additionalCount);
-
-    ASSERT_EQ(header.serialize().toHex(), QString(params.hexData).remove(" "));
-}
-
-INSTANTIATE_TEST_CASE_P(DNSHeaderTestInst,
-                        DNSHeaderTest,
-                        ::testing::Values(
-                                DNSHeaderTestParams {false, ""},
-                                DNSHeaderTestParams {false, "00"},
-                                DNSHeaderTestParams {true,
-                                                     "3c dc 01 00 00 01 00 00  00 00 00 00",
-                                                     0x3cdc,
-
-                                                     0x0100,
-                                                     false,
-                                                     0,
-                                                     false,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     false,
-                                                     false,
-                                                     false,
-                                                     0,
-
-                                                     1,
-                                                     0,
-                                                     0,
-                                                     0
-                                },
-                                DNSHeaderTestParams {true,
-                                                     "3c dc 81 80 00 01 00 01  00 00 00 00",
-                                                     0x3cdc,
-                                                     0x8180,
-                                                     true,
-                                                     0,
-                                                     false,
-                                                     false,
-                                                     true,
-                                                     true,
-                                                     false,
-                                                     false,
-                                                     false,
-                                                     0,
-
-                                                     1,
-                                                     1,
-                                                     0,
-                                                     0
-                                },
-
-                                DNSHeaderTestParams {true,
-                                                     "3c dc aa aa aa aa 55 55  55 ff ff 55",
-                                                     0x3cdc,
-                                                     0xaaaa,
-                                                     true,
-                                                     5,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     10,
-
-                                                     43690,
-                                                     21845,
-                                                     22015,
-                                                     65365
-                                },
-                                DNSHeaderTestParams {true,
-                                                     "3c dc 55 55 55 ff aa aa  ff 55 55 55",
-                                                     0x3cdc,
-                                                     0x5555,
-                                                     false,
-                                                     10,
-                                                     true,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     true,
-                                                     false,
-                                                     true,
-                                                     5,
-
-                                                     22015,
-                                                     43690,
-                                                     65365,
-                                                     21845
-                                }
-                        ));
-
-TEST(DNSHeaderTest, getFlagBits)
-{
-    QDns::QDnsHeader header;
-
-    header.setFlags(0x5555);
-    ASSERT_EQ(header.getFlagBits(0, 1), 0);
-    ASSERT_EQ(header.getFlagBits(3, 4), 5);
-}
-
-TEST(DNSHeaderTest, getFlagBitIndex)
-{
-    ASSERT_EQ(QDns::QDnsHeader::getFlagBitIndex(0), 15);
-    ASSERT_EQ(QDns::QDnsHeader::getFlagBitIndex(1), 14);
-    ASSERT_EQ(QDns::QDnsHeader::getFlagBitIndex(14), 1);
-    ASSERT_EQ(QDns::QDnsHeader::getFlagBitIndex(15), 0);
-}
 
 int main(int argc, char* argv[])
 {