init

.gitignore

@@ -0,0 +1,3 @@
+
+/cmake-build-*/
+.idea

CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+set(CMAKE_AUTOMOC ON)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Qt5Core REQUIRED)
+find_package(Qt5Network REQUIRED)
+set(PROJECT_LIBS Qt5::Core Qt5::Network)
+
+add_subdirectory(src)
+
+find_package(GTest)
+if (GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

src/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg)
+
+add_executable(qdnsagg
+        main.cpp
+        )
+
+add_subdirectory(modules/dns)
+
+target_link_libraries(qdnsagg Qt5::Core qdnsagg-dns)

src/main.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+#include <QCoreApplication>
+
+int main(int argc, char* argv[])
+{
+    QCoreApplication app(argc, argv);
+    std::cout << "Hello, World!" << std::endl;
+    return app.exec();
+}

src/modules/dns/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-dns)
+
+include_directories(includes)
+
+add_library(qdnsagg-dns
+        src/QDnsHeader.cpp
+        includes/dns/QDnsHeader.h
+        )
+
+target_link_libraries(qdnsagg-dns Qt5::Core Qt5::Network)

src/modules/dns/includes/dns/QDnsHeader.h

@@ -0,0 +1,85 @@
+//
+// Created by robin on 1/7/18.
+//
+
+#ifndef QDNSAGG_QDNSHEADER_H
+#define QDNSAGG_QDNSHEADER_H
+
+#include <qplatformdefs.h>
+#include <QByteArray>
+
+namespace QDNS
+{
+
+    class QDnsHeader
+    {
+    public:
+        QDnsHeader();
+
+        static QDnsHeader parse(const QByteArray& data);
+
+        bool isValid() const;
+
+        quint16 getId() const;
+        void setId(quint16 id);
+
+
+        quint16 getFlags() const;
+        void setFlags(quint16 flags);
+        void setFlagBits(quint8 bit, quint16 value, quint8 bitCount);
+        quint16 getFlagBits(quint8 bit, quint8 bitCount) const;
+        static quint8 getFlagBitIndex(quint8 bit);
+
+        bool isQuery() const;
+        void setIsQuery(bool isQuery);
+
+        quint8 getOpcode() const;
+        void setOpcode(quint8 opcode);
+
+        bool isAuthoritative() const;
+        void setIsAuthoritative(bool isAuthoritative);
+
+        bool isTruncated() const;
+        void setIsTruncated(bool isTruncated);
+
+        bool isRecursionDesired() const;
+        void setIsRecursionDesired(bool isRecursionDesired);
+
+        bool isRecursionAvailable() const;
+        void setIsRecursionAvailable(bool isRecursionAvailable);
+
+        bool isAnswerAuthenticated() const;
+        void setIsAnswerAuthenticated(bool isAnswerAuthenticated);
+
+        bool isNonAuthenticatedAcceptable() const;
+        void setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable);
+
+        quint8 getReplyCode() const;
+        void setReplyCode(quint8 replyCode);
+
+
+        quint16 getQuestionCount() const;
+        void setQuestionCount(quint16 questionCount);
+
+        quint16 getAnswerCount() const;
+        void setAnswerCount(quint16 answerCount);
+
+        quint16 getAuthorityCount() const;
+        void setAuthorityCount(quint16 authorityCount);
+
+        quint16 getAdditionalCount() const;
+        void setAdditionalCount(quint16 additionalCount);
+
+    private:
+        bool m_isValid;
+        quint16 m_id;
+        quint16 m_flags;
+        quint16 m_questionCount;
+        quint16 m_answerCount;
+        quint16 m_authorityCount;
+        quint16 m_additionalCount;
+    };
+
+}
+
+#endif //QDNSAGG_QDNSHEADER_H

src/modules/dns/src/QDnsHeader.cpp

@@ -0,0 +1,233 @@
+//
+// Created by robin on 1/7/18.
+//
+
+#include <QDataStream>
+#include "dns/QDnsHeader.h"
+
+namespace QDNS
+{
+
+    QDnsHeader::QDnsHeader()
+            : m_isValid(true)
+            , m_id(0)
+            , m_flags(0)
+            , m_questionCount(0)
+            , m_answerCount(0)
+            , m_authorityCount(0)
+            , m_additionalCount(0)
+    {
+
+    }
+
+    QDnsHeader QDnsHeader::parse(const QByteArray& data)
+    {
+        QDnsHeader header;
+
+        if (data.size() < 12)
+        {
+            header.m_isValid = false;
+        }
+        else
+        {
+            QDataStream ds(data);
+            ds >> header.m_id;
+            ds >> header.m_flags;
+            ds >> header.m_questionCount;
+            ds >> header.m_answerCount;
+            ds >> header.m_authorityCount;
+            ds >> header.m_additionalCount;
+        }
+
+        return header;
+    }
+
+    bool QDnsHeader::isValid() const
+    {
+        return m_isValid;
+    }
+
+    quint16 QDnsHeader::getId() const
+    {
+        return m_id;
+    }
+
+    void QDnsHeader::setId(quint16 id)
+    {
+        m_id = id;
+    }
+
+    quint16 QDnsHeader::getFlags() const
+    {
+        return m_flags;
+    }
+
+    void QDnsHeader::setFlags(quint16 flags)
+    {
+        m_flags = flags;
+    }
+
+    void QDnsHeader::setFlagBits(quint8 bit, quint16 value, quint8 bitCount)
+    {
+        quint8 baseBit = getFlagBitIndex(bit);
+        for (quint8 i = 0; i < bitCount; ++i) // TODO might be optimized
+        {
+            if ((value >> i) & 1)
+            {
+                m_flags |= 1UL << (baseBit + i);
+            }
+            else
+            {
+                m_flags &= ~(1UL << (baseBit + i));
+            }
+        }
+    }
+
+    quint16 QDnsHeader::getFlagBits(quint8 bit, quint8 bitCount) const
+    {
+        quint8 mask = 1;
+        for (quint8 i = 1; i < bitCount; ++i)
+        {
+            mask += 1 << i;
+        }
+        auto value = (quint16) ((m_flags >> getFlagBitIndex(bit)) & mask);
+        return value;
+    }
+
+    quint8 QDnsHeader::getFlagBitIndex(quint8 bit)
+    {
+        auto index = ((sizeof(m_flags) * 8) - bit - 1);
+        return index;
+    }
+
+    bool QDnsHeader::isQuery() const
+    {
+        return (bool) getFlagBits(0, 1);
+    }
+
+    void QDnsHeader::setIsQuery(bool isQuery)
+    {
+        setFlagBits(0, (quint8) isQuery, 1);
+    }
+
+    quint8 QDnsHeader::getOpcode() const
+    {
+        return (quint8) getFlagBits(4, 4);
+    }
+
+    void QDnsHeader::setOpcode(quint8 opcode)
+    {
+        setFlagBits(4, opcode, 4);
+    }
+
+    bool QDnsHeader::isAuthoritative() const
+    {
+        return (bool) getFlagBits(5, 1);
+    }
+
+    void QDnsHeader::setIsAuthoritative(bool isAuthoritative)
+    {
+        setFlagBits(5, (quint8) isAuthoritative, 1);
+    }
+
+    bool QDnsHeader::isTruncated() const
+    {
+        return (bool) getFlagBits(6, 1);
+    }
+
+    void QDnsHeader::setIsTruncated(bool isTruncated)
+    {
+        setFlagBits(6, (quint8) isTruncated, 1);
+    }
+
+    bool QDnsHeader::isRecursionDesired() const
+    {
+        return (bool) getFlagBits(7, 1);
+    }
+
+    void QDnsHeader::setIsRecursionDesired(bool isRecursionDesired)
+    {
+        setFlagBits(7, (quint8) isRecursionDesired, 1);
+    }
+
+    bool QDnsHeader::isRecursionAvailable() const
+    {
+        return (bool) getFlagBits(8, 1);
+    }
+
+    void QDnsHeader::setIsRecursionAvailable(bool isRecursionAvailable)
+    {
+        setFlagBits(8, (quint8) isRecursionAvailable, 1);
+    }
+
+    bool QDnsHeader::isAnswerAuthenticated() const
+    {
+        return (bool) getFlagBits(10, 1);
+    }
+
+    void QDnsHeader::setIsAnswerAuthenticated(bool isAnswerAuthenticated)
+    {
+        setFlagBits(10, (quint8) isAnswerAuthenticated, 1);
+    }
+
+    bool QDnsHeader::isNonAuthenticatedAcceptable() const
+    {
+        return (bool) getFlagBits(11, 1);
+    }
+
+    void QDnsHeader::setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable)
+    {
+        setFlagBits(11, (quint8) isNonAuthenticatedAcceptable, 1);
+    }
+
+    quint8 QDnsHeader::getReplyCode() const
+    {
+        return (quint8) getFlagBits(15, 4);
+    }
+
+    void QDnsHeader::setReplyCode(quint8 replyCode)
+    {
+        setFlagBits(15, (quint8) replyCode, 4);
+    }
+
+    quint16 QDnsHeader::getQuestionCount() const
+    {
+        return m_questionCount;
+    }
+
+    void QDnsHeader::setQuestionCount(quint16 questionCount)
+    {
+        m_questionCount = questionCount;
+    }
+
+    quint16 QDnsHeader::getAnswerCount() const
+    {
+        return m_answerCount;
+    }
+
+    void QDnsHeader::setAnswerCount(quint16 answerCount)
+    {
+        m_answerCount = answerCount;
+    }
+
+    quint16 QDnsHeader::getAuthorityCount() const
+    {
+        return m_authorityCount;
+    }
+
+    void QDnsHeader::setAuthorityCount(quint16 authorityCount)
+    {
+        m_authorityCount = authorityCount;
+    }
+
+    quint16 QDnsHeader::getAdditionalCount() const
+    {
+        return m_additionalCount;
+    }
+
+    void QDnsHeader::setAdditionalCount(quint16 additionalCount)
+    {
+        m_additionalCount = additionalCount;
+    }
+
+}

tests/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.9)
+project(qdnsagg-tests)
+
+enable_testing()
+
+include_directories(../src/modules/dns/includes)
+
+add_executable(qdnsagg-tests
+        main.cpp
+        )
+
+target_link_libraries(qdnsagg-tests gtest pthread qdnsagg-dns)
+add_test(qdnsagg-tests ${CMAKE_CURRENT_BINARY_DIR}/qdnsagg-tests)

tests/main.cpp

@@ -0,0 +1,246 @@
+#include <gtest/gtest.h>
+#include <QtCore/QByteArray>
+
+#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);
+    }
+}
+
+TEST_P(DNSHeaderTest, settersAndGetters1)
+{
+    auto params = GetParam();
+    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);
+}
+
+TEST_P(DNSHeaderTest, settersAndGetters2)
+{
+    auto params = GetParam();
+    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);
+}
+
+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[])
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}