Added Base namespace

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

@@ -11,79 +11,101 @@
 
 namespace QDns
 {
-
-    class QDnsHeader
+    namespace Base
     {
-    public:
-        QDnsHeader();
+        class QDnsHeader
+        {
+        public:
+            QDnsHeader();
+
+            static QDnsHeader parse(const QByteArray &data);
+
+            static QDnsHeader parse(QDataStream &dataStream);
+
+            QByteArray serialize() const;
+
+            void serialize(QDataStream &dataStream) const;
+
+            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;
 
-        static QDnsHeader parse(const QByteArray& data);
-        static QDnsHeader parse(QDataStream& dataStream);
-        QByteArray serialize() const;
-        void serialize(QDataStream& dataStream) const;
+            void setIsTruncated(bool isTruncated);
 
-        bool isValid() const;
+            bool isRecursionDesired() const;
 
-        quint16 getId() const;
-        void setId(quint16 id);
+            void setIsRecursionDesired(bool isRecursionDesired);
 
+            bool isRecursionAvailable() const;
 
-        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);
+            void setIsRecursionAvailable(bool isRecursionAvailable);
 
-        bool isQuery() const;
-        void setIsQuery(bool isQuery);
+            bool isAnswerAuthenticated() const;
 
-        quint8 getOpcode() const;
-        void setOpcode(quint8 opcode);
+            void setIsAnswerAuthenticated(bool isAnswerAuthenticated);
 
-        bool isAuthoritative() const;
-        void setIsAuthoritative(bool isAuthoritative);
+            bool isNonAuthenticatedAcceptable() const;
 
-        bool isTruncated() const;
-        void setIsTruncated(bool isTruncated);
+            void setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable);
 
-        bool isRecursionDesired() const;
-        void setIsRecursionDesired(bool isRecursionDesired);
+            quint8 getReplyCode() const;
 
-        bool isRecursionAvailable() const;
-        void setIsRecursionAvailable(bool isRecursionAvailable);
+            void setReplyCode(quint8 replyCode);
 
-        bool isAnswerAuthenticated() const;
-        void setIsAnswerAuthenticated(bool isAnswerAuthenticated);
 
-        bool isNonAuthenticatedAcceptable() const;
-        void setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable);
+            quint16 getQueryCount() const;
 
-        quint8 getReplyCode() const;
-        void setReplyCode(quint8 replyCode);
+            void setQueryCount(quint16 questionCount);
 
+            quint16 getAnswerCount() const;
 
-        quint16 getQueryCount() const;
-        void setQueryCount(quint16 questionCount);
+            void setAnswerCount(quint16 answerCount);
 
-        quint16 getAnswerCount() const;
-        void setAnswerCount(quint16 answerCount);
+            quint16 getAuthorityCount() const;
 
-        quint16 getAuthorityCount() const;
-        void setAuthorityCount(quint16 authorityCount);
+            void setAuthorityCount(quint16 authorityCount);
 
-        quint16 getAdditionalCount() const;
-        void setAdditionalCount(quint16 additionalCount);
+            quint16 getAdditionalCount() const;
 
-    private:
-        bool m_isValid;
-        quint16 m_id;
-        quint16 m_flags;
-        quint16 m_queryCount;
-        quint16 m_answerCount;
-        quint16 m_authorityCount;
-        quint16 m_additionalCount;
-    };
+            void setAdditionalCount(quint16 additionalCount);
 
+        private:
+            bool m_isValid;
+            quint16 m_id;
+            quint16 m_flags;
+            quint16 m_queryCount;
+            quint16 m_answerCount;
+            quint16 m_authorityCount;
+            quint16 m_additionalCount;
+        };
+    }
 }
 
 #endif //QDNSAGG_QDNSHEADER_H

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

@@ -10,19 +10,22 @@
 
 namespace QDns
 {
-
-    class QDnsLabel
+    namespace Base
     {
-    public:
-        QDnsLabel() = delete;
+        class QDnsLabel
+        {
+        public:
+            QDnsLabel() = delete;
+
+            static QString parse(const QByteArray &packetData, 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);
+            static QString parse(const QByteArray &packetData, QDataStream &dataStream, quint8 maxRecursion = 5);
 
-        static QByteArray serialize(const QString& label);
-        static void serialize(const QString& label, QDataStream& dataStream);
-    };
+            static QByteArray serialize(const QString &label);
 
+            static void serialize(const QString &label, QDataStream &dataStream);
+        };
+    }
 }
 
 #endif //QDNSAGG_QDNSLABEL_H

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

@@ -12,50 +12,54 @@
 
 namespace QDns
 {
-
-    class QDnsPacket
+    namespace Base
     {
-    public:
-        QDnsPacket();
+        class QDnsPacket
+        {
+        public:
+            QDnsPacket();
+
+            static QDnsPacket parse(const QByteArray &data);
+
+            static QDnsPacket parse(const QByteArray &data, QDataStream &dataStream);
 
-        static QDnsPacket parse(const QByteArray& data);
-        static QDnsPacket parse(const QByteArray& data, QDataStream& dataStream);
-        QByteArray serialize() const;
-        void serialize(QDataStream& dataStream) const;
+            QByteArray serialize() const;
 
-        bool isValid() const;
+            void serialize(QDataStream &dataStream) const;
 
-        const QDnsHeader& getHeader() const;
+            bool isValid() const;
 
-        void setHeader(const QDnsHeader& header);
+            const QDnsHeader &getHeader() const;
 
-        const QList<QDnsQuery>& getQueries() const;
+            void setHeader(const QDnsHeader &header);
 
-        void setQueries(const QList<QDnsQuery>& queries);
+            const QList<QDnsQuery> &getQueries() const;
 
-        const QList<QDnsResourceRecord>& getAnswerRecords() const;
+            void setQueries(const QList<QDnsQuery> &queries);
 
-        void setAnswerRecords(const QList<QDnsResourceRecord>& answerRecords);
+            const QList<QDnsResourceRecord> &getAnswerRecords() const;
 
-        const QList<QDnsResourceRecord>& getAuthorityRecords() const;
+            void setAnswerRecords(const QList<QDnsResourceRecord> &answerRecords);
 
-        void setAuthorityRecords(const QList<QDnsResourceRecord>& authorityRecords);
+            const QList<QDnsResourceRecord> &getAuthorityRecords() const;
 
-        const QList<QDnsResourceRecord>& getAdditionalRecords() const;
+            void setAuthorityRecords(const QList<QDnsResourceRecord> &authorityRecords);
 
-        void setAdditionalRecords(const QList<QDnsResourceRecord>& additionalRecords);
+            const QList<QDnsResourceRecord> &getAdditionalRecords() const;
 
-    private:
-        bool m_isValid;
+            void setAdditionalRecords(const QList<QDnsResourceRecord> &additionalRecords);
 
-        QDnsHeader m_header;
+        private:
+            bool m_isValid;
 
-        QList<QDnsQuery> m_queries;
-        QList<QDnsResourceRecord> m_answerRecords;
-        QList<QDnsResourceRecord> m_authorityRecords;
-        QList<QDnsResourceRecord> m_additionalRecords;
-    };
+            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-base/includes/dns-base/QDnsQuery.h

@@ -10,36 +10,43 @@
 
 namespace QDns
 {
-
-    class QDnsQuery
+    namespace Base
     {
-    public:
-        QDnsQuery();
+        class QDnsQuery
+        {
+        public:
+            QDnsQuery();
+
+            static QDnsQuery parse(const QByteArray &packetData, quint32 pos);
+
+            static QDnsQuery parse(const QByteArray &packetData, QDataStream &dataStream);
+
+            QByteArray serialize() const;
+
+            void serialize(QDataStream &dataStream) const;
+
+            bool isValid() const;
 
-        static QDnsQuery parse(const QByteArray& packetData, quint32 pos);
-        static QDnsQuery parse(const QByteArray& packetData, QDataStream& dataStream);
-        QByteArray serialize() const;
-        void serialize(QDataStream& dataStream) const;
+            const QString &getName() const;
 
-        bool isValid() const;
+            void setName(const QString &name);
 
-        const QString& getName() const;
-        void setName(const QString& name);
+            quint16 getType() const;
 
-        quint16 getType() const;
-        void setType(quint16 type);
+            void setType(quint16 type);
 
-        quint16 getClass() const;
-        void setClass(quint16 aClass);
+            quint16 getClass() const;
 
-    private:
-        bool m_isValid;
+            void setClass(quint16 aClass);
 
-        QString m_name;
-        quint16 m_type;
-        quint16 m_class;
-    };
+        private:
+            bool m_isValid;
 
+            QString m_name;
+            quint16 m_type;
+            quint16 m_class;
+        };
+    }
 }
 
 #endif //QDNSAGG_QDNSQUERY_H

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

@@ -11,49 +11,53 @@
 
 namespace QDns
 {
-
-    class QDnsResourceRecord
+    namespace Base
     {
-    public:
-        QDnsResourceRecord();
+        class QDnsResourceRecord
+        {
+        public:
+            QDnsResourceRecord();
+
+            static QDnsResourceRecord parse(const QByteArray &packetData, quint32 pos);
+
+            static QDnsResourceRecord parse(const QByteArray &packetData, QDataStream &dataStream);
 
-        static QDnsResourceRecord parse(const QByteArray& packetData, quint32 pos);
-        static QDnsResourceRecord parse(const QByteArray& packetData, QDataStream& dataStream);
-        QByteArray serialize() const;
-        void serialize(QDataStream& dataStream) const;
+            QByteArray serialize() const;
 
-        bool isValid() const;
+            void serialize(QDataStream &dataStream) const;
 
-        const QString& getName() const;
+            bool isValid() const;
 
-        void setName(const QString& name);
+            const QString &getName() const;
 
-        quint16 getType() const;
+            void setName(const QString &name);
 
-        void setType(quint16 type);
+            quint16 getType() const;
 
-        quint16 getClass() const;
+            void setType(quint16 type);
 
-        void setClass(quint16 aClass);
+            quint16 getClass() const;
 
-        quint32 getTtl() const;
+            void setClass(quint16 aClass);
 
-        void setTtl(quint32 ttl);
+            quint32 getTtl() const;
 
-        const QByteArray& getData() const;
+            void setTtl(quint32 ttl);
 
-        void setData(const QByteArray& data);
+            const QByteArray &getData() const;
 
-    private:
-        bool m_isValid;
+            void setData(const QByteArray &data);
 
-        QString m_name;
-        quint16 m_type;
-        quint16 m_class;
-        quint32 m_ttl;
-        QByteArray m_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-base/src/QDnsHeader.cpp

@@ -6,250 +6,251 @@
 
 namespace QDns
 {
+    namespace Base
+    {
+        QDnsHeader::QDnsHeader()
+                : m_isValid(true)
+                  , m_id(0)
+                  , m_flags(0)
+                  , m_queryCount(0)
+                  , m_answerCount(0)
+                  , m_authorityCount(0)
+                  , m_additionalCount(0)
+        {
 
-    QDnsHeader::QDnsHeader()
-            : m_isValid(true)
-            , m_id(0)
-            , m_flags(0)
-            , m_queryCount(0)
-            , m_answerCount(0)
-            , m_authorityCount(0)
-            , m_additionalCount(0)
-    {
+        }
 
-    }
+        QDnsHeader QDnsHeader::parse(const QByteArray &data)
+        {
+            QDataStream dataStream(data);
+            return QDnsHeader::parse(dataStream);
+        }
 
-    QDnsHeader QDnsHeader::parse(const QByteArray& data)
-    {
-        QDataStream dataStream(data);
-        return QDnsHeader::parse(dataStream);
-    }
+        QDnsHeader QDnsHeader::parse(QDataStream &dataStream)
+        {
+            QDnsHeader header;
 
-    QDnsHeader QDnsHeader::parse(QDataStream& dataStream)
-    {
-        QDnsHeader header;
+            if (dataStream.device()->bytesAvailable() < 12)
+            {
+                header.m_isValid = false;
+            }
+            else
+            {
+                dataStream >> header.m_id;
+                dataStream >> header.m_flags;
+                dataStream >> header.m_queryCount;
+                dataStream >> header.m_answerCount;
+                dataStream >> header.m_authorityCount;
+                dataStream >> header.m_additionalCount;
+            }
 
-        if (dataStream.device()->bytesAvailable() < 12)
-        {
-            header.m_isValid = false;
+            return header;
         }
-        else
+
+        QByteArray QDnsHeader::serialize() const
         {
-            dataStream >> header.m_id;
-            dataStream >> header.m_flags;
-            dataStream >> header.m_queryCount;
-            dataStream >> header.m_answerCount;
-            dataStream >> header.m_authorityCount;
-            dataStream >> header.m_additionalCount;
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
         }
 
-        return header;
-    }
-
-    QByteArray QDnsHeader::serialize() const
-    {
-        QByteArray byteArray;
-        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
-        serialize(dataStream);
-        return byteArray;
-    }
-
-    void QDnsHeader::serialize(QDataStream& dataStream) const
-    {
-        dataStream << m_id;
-        dataStream << m_flags;
-        dataStream << m_queryCount;
-        dataStream << m_answerCount;
-        dataStream << m_authorityCount;
-        dataStream << m_additionalCount;
-    }
+        void QDnsHeader::serialize(QDataStream &dataStream) const
+        {
+            dataStream << m_id;
+            dataStream << m_flags;
+            dataStream << m_queryCount;
+            dataStream << m_answerCount;
+            dataStream << m_authorityCount;
+            dataStream << m_additionalCount;
+        }
 
-    bool QDnsHeader::isValid() const
-    {
-        return m_isValid;
-    }
+        bool QDnsHeader::isValid() const
+        {
+            return m_isValid;
+        }
 
-    quint16 QDnsHeader::getId() const
-    {
-        return m_id;
-    }
+        quint16 QDnsHeader::getId() const
+        {
+            return m_id;
+        }
 
-    void QDnsHeader::setId(quint16 id)
-    {
-        m_id = id;
-    }
+        void QDnsHeader::setId(quint16 id)
+        {
+            m_id = id;
+        }
 
-    quint16 QDnsHeader::getFlags() const
-    {
-        return m_flags;
-    }
+        quint16 QDnsHeader::getFlags() const
+        {
+            return m_flags;
+        }
 
-    void QDnsHeader::setFlags(quint16 flags)
-    {
-        m_flags = 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
+        void QDnsHeader::setFlagBits(quint8 bit, quint16 value, quint8 bitCount)
         {
-            if ((value >> i) & 1)
+            quint8 baseBit = getFlagBitIndex(bit);
+            for (quint8 i = 0; i < bitCount; ++i) // TODO might be optimized
             {
-                m_flags |= 1UL << (baseBit + i);
+                if ((value >> i) & 1)
+                {
+                    m_flags |= 1UL << (baseBit + i);
+                }
+                else
+                {
+                    m_flags &= ~(1UL << (baseBit + i));
+                }
             }
-            else
+        }
+
+        quint16 QDnsHeader::getFlagBits(quint8 bit, quint8 bitCount) const
+        {
+            quint8 mask = 1;
+            for (quint8 i = 1; i < bitCount; ++i)
             {
-                m_flags &= ~(1UL << (baseBit + i));
+                mask += 1 << i;
             }
+            auto value = (quint16) ((m_flags >> getFlagBitIndex(bit)) & mask);
+            return value;
         }
-    }
 
-    quint16 QDnsHeader::getFlagBits(quint8 bit, quint8 bitCount) const
-    {
-        quint8 mask = 1;
-        for (quint8 i = 1; i < bitCount; ++i)
+        quint8 QDnsHeader::getFlagBitIndex(quint8 bit)
         {
-            mask += 1 << i;
+            auto index = ((sizeof(m_flags) * 8) - bit - 1);
+            return index;
         }
-        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);
-    }
+        bool QDnsHeader::isQuery() const
+        {
+            return (bool) getFlagBits(0, 1);
+        }
 
-    void QDnsHeader::setIsQuery(bool isQuery)
-    {
-        setFlagBits(0, (quint8) isQuery, 1);
-    }
+        void QDnsHeader::setIsQuery(bool isQuery)
+        {
+            setFlagBits(0, (quint8) isQuery, 1);
+        }
 
-    quint8 QDnsHeader::getOpcode() const
-    {
-        return (quint8) getFlagBits(4, 4);
-    }
+        quint8 QDnsHeader::getOpcode() const
+        {
+            return (quint8) getFlagBits(4, 4);
+        }
 
-    void QDnsHeader::setOpcode(quint8 opcode)
-    {
-        setFlagBits(4, opcode, 4);
-    }
+        void QDnsHeader::setOpcode(quint8 opcode)
+        {
+            setFlagBits(4, opcode, 4);
+        }
 
-    bool QDnsHeader::isAuthoritative() const
-    {
-        return (bool) getFlagBits(5, 1);
-    }
+        bool QDnsHeader::isAuthoritative() const
+        {
+            return (bool) getFlagBits(5, 1);
+        }
 
-    void QDnsHeader::setIsAuthoritative(bool isAuthoritative)
-    {
-        setFlagBits(5, (quint8) isAuthoritative, 1);
-    }
+        void QDnsHeader::setIsAuthoritative(bool isAuthoritative)
+        {
+            setFlagBits(5, (quint8) isAuthoritative, 1);
+        }
 
-    bool QDnsHeader::isTruncated() const
-    {
-        return (bool) getFlagBits(6, 1);
-    }
+        bool QDnsHeader::isTruncated() const
+        {
+            return (bool) getFlagBits(6, 1);
+        }
 
-    void QDnsHeader::setIsTruncated(bool isTruncated)
-    {
-        setFlagBits(6, (quint8) isTruncated, 1);
-    }
+        void QDnsHeader::setIsTruncated(bool isTruncated)
+        {
+            setFlagBits(6, (quint8) isTruncated, 1);
+        }
 
-    bool QDnsHeader::isRecursionDesired() const
-    {
-        return (bool) getFlagBits(7, 1);
-    }
+        bool QDnsHeader::isRecursionDesired() const
+        {
+            return (bool) getFlagBits(7, 1);
+        }
 
-    void QDnsHeader::setIsRecursionDesired(bool isRecursionDesired)
-    {
-        setFlagBits(7, (quint8) isRecursionDesired, 1);
-    }
+        void QDnsHeader::setIsRecursionDesired(bool isRecursionDesired)
+        {
+            setFlagBits(7, (quint8) isRecursionDesired, 1);
+        }
 
-    bool QDnsHeader::isRecursionAvailable() const
-    {
-        return (bool) getFlagBits(8, 1);
-    }
+        bool QDnsHeader::isRecursionAvailable() const
+        {
+            return (bool) getFlagBits(8, 1);
+        }
 
-    void QDnsHeader::setIsRecursionAvailable(bool isRecursionAvailable)
-    {
-        setFlagBits(8, (quint8) isRecursionAvailable, 1);
-    }
+        void QDnsHeader::setIsRecursionAvailable(bool isRecursionAvailable)
+        {
+            setFlagBits(8, (quint8) isRecursionAvailable, 1);
+        }
 
-    bool QDnsHeader::isAnswerAuthenticated() const
-    {
-        return (bool) getFlagBits(10, 1);
-    }
+        bool QDnsHeader::isAnswerAuthenticated() const
+        {
+            return (bool) getFlagBits(10, 1);
+        }
 
-    void QDnsHeader::setIsAnswerAuthenticated(bool isAnswerAuthenticated)
-    {
-        setFlagBits(10, (quint8) isAnswerAuthenticated, 1);
-    }
+        void QDnsHeader::setIsAnswerAuthenticated(bool isAnswerAuthenticated)
+        {
+            setFlagBits(10, (quint8) isAnswerAuthenticated, 1);
+        }
 
-    bool QDnsHeader::isNonAuthenticatedAcceptable() const
-    {
-        return (bool) getFlagBits(11, 1);
-    }
+        bool QDnsHeader::isNonAuthenticatedAcceptable() const
+        {
+            return (bool) getFlagBits(11, 1);
+        }
 
-    void QDnsHeader::setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable)
-    {
-        setFlagBits(11, (quint8) isNonAuthenticatedAcceptable, 1);
-    }
+        void QDnsHeader::setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable)
+        {
+            setFlagBits(11, (quint8) isNonAuthenticatedAcceptable, 1);
+        }
 
-    quint8 QDnsHeader::getReplyCode() const
-    {
-        return (quint8) getFlagBits(15, 4);
-    }
+        quint8 QDnsHeader::getReplyCode() const
+        {
+            return (quint8) getFlagBits(15, 4);
+        }
 
-    void QDnsHeader::setReplyCode(quint8 replyCode)
-    {
-        setFlagBits(15, (quint8) replyCode, 4);
-    }
+        void QDnsHeader::setReplyCode(quint8 replyCode)
+        {
+            setFlagBits(15, (quint8) replyCode, 4);
+        }
 
-    quint16 QDnsHeader::getQueryCount() const
-    {
-        return m_queryCount;
-    }
+        quint16 QDnsHeader::getQueryCount() const
+        {
+            return m_queryCount;
+        }
 
-    void QDnsHeader::setQueryCount(quint16 questionCount)
-    {
-        m_queryCount = questionCount;
-    }
+        void QDnsHeader::setQueryCount(quint16 questionCount)
+        {
+            m_queryCount = questionCount;
+        }
 
-    quint16 QDnsHeader::getAnswerCount() const
-    {
-        return m_answerCount;
-    }
+        quint16 QDnsHeader::getAnswerCount() const
+        {
+            return m_answerCount;
+        }
 
-    void QDnsHeader::setAnswerCount(quint16 answerCount)
-    {
-        m_answerCount = answerCount;
-    }
+        void QDnsHeader::setAnswerCount(quint16 answerCount)
+        {
+            m_answerCount = answerCount;
+        }
 
-    quint16 QDnsHeader::getAuthorityCount() const
-    {
-        return m_authorityCount;
-    }
+        quint16 QDnsHeader::getAuthorityCount() const
+        {
+            return m_authorityCount;
+        }
 
-    void QDnsHeader::setAuthorityCount(quint16 authorityCount)
-    {
-        m_authorityCount = authorityCount;
-    }
+        void QDnsHeader::setAuthorityCount(quint16 authorityCount)
+        {
+            m_authorityCount = authorityCount;
+        }
 
-    quint16 QDnsHeader::getAdditionalCount() const
-    {
-        return m_additionalCount;
-    }
+        quint16 QDnsHeader::getAdditionalCount() const
+        {
+            return m_additionalCount;
+        }
 
-    void QDnsHeader::setAdditionalCount(quint16 additionalCount)
-    {
-        m_additionalCount = additionalCount;
+        void QDnsHeader::setAdditionalCount(quint16 additionalCount)
+        {
+            m_additionalCount = additionalCount;
+        }
     }
-
 }

src/modules/dns-base/src/QDnsLabel.cpp

@@ -6,106 +6,107 @@
 
 namespace QDns
 {
-
-    QString QDnsLabel::parse(const QByteArray& packetData, quint32 pos, quint8 maxRecursion)
+    namespace Base
     {
-        QDataStream dataStream(packetData);
-        dataStream.skipRawData(pos);
-        return parse(packetData, dataStream, maxRecursion);
-    }
-
-    QString QDnsLabel::parse(const QByteArray& packetData, QDataStream& dataStream, quint8 maxRecursion)
-    {
-        if (maxRecursion == 0)
-        {
-            return QString::null;
-        }
-
-        QString fullLabel = "";
-
-        if (dataStream.device()->bytesAvailable() < 1)
+        QString QDnsLabel::parse(const QByteArray &packetData, quint32 pos, quint8 maxRecursion)
         {
-            return QString::null;
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            return parse(packetData, dataStream, maxRecursion);
         }
 
-        quint8 labelSize;
-        dataStream >> labelSize;
-        while (labelSize != 0)
+        QString QDnsLabel::parse(const QByteArray &packetData, QDataStream &dataStream, quint8 maxRecursion)
         {
-            if (labelSize >> 6 == 3)
+            if (maxRecursion == 0)
             {
-                if (dataStream.device()->bytesAvailable() < 1)
-                {
-                    return QString::null;
-                }
-                quint8 labelSize2;
-                dataStream >> labelSize2;
-                quint16 pointer = ((labelSize << 8) | labelSize2) - (quint16) 49152;
-                QDataStream dataStream2(packetData);
-                dataStream2.skipRawData(pointer);
-                auto labelEnd = parse(packetData, dataStream2, maxRecursion - (quint8) 1);
-                if (labelEnd.isNull())
-                {
-                    return QString::null;
-                }
-                if (!fullLabel.isEmpty())
-                {
-                    fullLabel.append(".");
-                }
-                fullLabel.append(labelEnd);
-                break;
+                return QString::null;
             }
-            else if (labelSize >> 6 == 0)
+
+            QString fullLabel = "";
+
+            if (dataStream.device()->bytesAvailable() < 1)
             {
+                return QString::null;
+            }
 
-                if (dataStream.device()->bytesAvailable() < labelSize + 1)
+            quint8 labelSize;
+            dataStream >> labelSize;
+            while (labelSize != 0)
+            {
+                if (labelSize >> 6 == 3)
                 {
-                    return QString::null;
+                    if (dataStream.device()->bytesAvailable() < 1)
+                    {
+                        return QString::null;
+                    }
+                    quint8 labelSize2;
+                    dataStream >> labelSize2;
+                    quint16 pointer = ((labelSize << 8) | labelSize2) - (quint16) 49152;
+                    QDataStream dataStream2(packetData);
+                    dataStream2.skipRawData(pointer);
+                    auto labelEnd = parse(packetData, dataStream2, maxRecursion - (quint8) 1);
+                    if (labelEnd.isNull())
+                    {
+                        return QString::null;
+                    }
+                    if (!fullLabel.isEmpty())
+                    {
+                        fullLabel.append(".");
+                    }
+                    fullLabel.append(labelEnd);
+                    break;
                 }
-
-                char label[labelSize];
-                int read = dataStream.readRawData(label, labelSize);
-                if (read != labelSize)
+                else if (labelSize >> 6 == 0)
                 {
-                    return QString::null;
+
+                    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;
                 }
-                if (!fullLabel.isEmpty())
+                else
                 {
-                    fullLabel.append(".");
+                    return QString::null;
                 }
-                fullLabel.append(QByteArray(label, labelSize));
-                dataStream >> labelSize;
-            }
-            else
-            {
-                return QString::null;
             }
+            return fullLabel;
         }
-        return fullLabel;
-    }
 
-    QByteArray QDnsLabel::serialize(const QString& label)
-    {
-        QByteArray data;
-        QDataStream dataStream(&data, QIODevice::WriteOnly);
-        serialize(label, dataStream);
-        return data;
-    }
+        QByteArray QDnsLabel::serialize(const QString &label)
+        {
+            QByteArray data;
+            QDataStream dataStream(&data, QIODevice::WriteOnly);
+            serialize(label, dataStream);
+            return data;
+        }
 
-    void QDnsLabel::serialize(const QString& label, QDataStream& dataStream)
-    {
-        if (label.size() != 0)
+        void QDnsLabel::serialize(const QString &label, QDataStream &dataStream)
         {
-            for (const auto& part : label.split("."))
+            if (label.size() != 0)
             {
-                dataStream << (quint8) part.length();
-                for (const auto& c : part)
+                for (const auto &part : label.split("."))
                 {
-                    dataStream << (quint8) c.toLatin1();
+                    dataStream << (quint8) part.length();
+                    for (const auto &c : part)
+                    {
+                        dataStream << (quint8) c.toLatin1();
+                    }
                 }
             }
+            dataStream << (quint8) 0;
         }
-        dataStream << (quint8) 0;
     }
-
 }

src/modules/dns-base/src/QDnsPacket.cpp

@@ -6,159 +6,161 @@
 
 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)
+    namespace Base
     {
-        QDnsPacket packet;
+        QDnsPacket::QDnsPacket()
+                : m_isValid(true)
+        {
+        }
 
-        packet.m_header = QDnsHeader::parse(dataStream);
-        if (!packet.m_header.isValid())
+        QDnsPacket QDnsPacket::parse(const QByteArray &data)
         {
-            packet.m_isValid = false;
+            QDataStream dataStream(data);
+            return parse(data, dataStream);
         }
-        else
+
+        QDnsPacket QDnsPacket::parse(const QByteArray &data, QDataStream &dataStream)
         {
-            for (quint16 i = 0; i < packet.m_header.getQueryCount() && packet.m_isValid; ++i)
+            QDnsPacket packet;
+
+            packet.m_header = QDnsHeader::parse(dataStream);
+            if (!packet.m_header.isValid())
             {
-                auto entry = QDnsQuery::parse(data, dataStream);
-                if (!entry.isValid())
-                {
-                    packet.m_isValid = false;
-                }
-                packet.m_queries.append(entry);
+                packet.m_isValid = false;
             }
-            for (quint16 i = 0; i < packet.m_header.getAnswerCount() && packet.m_isValid; ++i)
+            else
             {
-                auto entry = QDnsResourceRecord::parse(data, dataStream);
-                if (!entry.isValid())
+                for (quint16 i = 0; i < packet.m_header.getQueryCount() && packet.m_isValid; ++i)
                 {
-                    packet.m_isValid = false;
+                    auto entry = QDnsQuery::parse(data, dataStream);
+                    if (!entry.isValid())
+                    {
+                        packet.m_isValid = false;
+                    }
+                    packet.m_queries.append(entry);
                 }
-                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())
+                for (quint16 i = 0; i < packet.m_header.getAnswerCount() && packet.m_isValid; ++i)
                 {
-                    packet.m_isValid = false;
+                    auto entry = QDnsResourceRecord::parse(data, dataStream);
+                    if (!entry.isValid())
+                    {
+                        packet.m_isValid = false;
+                    }
+                    packet.m_answerRecords.append(entry);
                 }
-                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())
+                for (quint16 i = 0; i < packet.m_header.getAuthorityCount() && packet.m_isValid; ++i)
                 {
-                    packet.m_isValid = false;
+                    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);
                 }
-                packet.m_additionalRecords.append(entry);
             }
-        }
 
-        return packet;
-    }
-
-    QByteArray QDnsPacket::serialize() const
-    {
-        QByteArray byteArray;
-        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
-        serialize(dataStream);
-        return byteArray;
-    }
+            return packet;
+        }
 
-    void QDnsPacket::serialize(QDataStream& dataStream) const
-    {
-        m_header.serialize(dataStream);
-        for (const auto& entry : m_queries)
+        QByteArray QDnsPacket::serialize() const
         {
-            entry.serialize(dataStream);
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
         }
-        for (const auto& entry : m_answerRecords)
+
+        void QDnsPacket::serialize(QDataStream &dataStream) const
         {
-            entry.serialize(dataStream);
+            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);
+            }
         }
-        for (const auto& entry : m_authorityRecords)
+
+        bool QDnsPacket::isValid() const
         {
-            entry.serialize(dataStream);
+            return m_isValid;
         }
-        for (const auto& entry : m_additionalRecords)
+
+        const QDnsHeader &QDnsPacket::getHeader() const
         {
-            entry.serialize(dataStream);
+            return m_header;
         }
-    }
 
-    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());
-    }
+        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;
-    }
+        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());
-    }
+        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;
-    }
+        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());
-    }
+        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;
-    }
+        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());
-    }
+        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;
-    }
+        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());
+        void QDnsPacket::setAdditionalRecords(const QList<QDnsResourceRecord> &additionalRecords)
+        {
+            m_additionalRecords = additionalRecords;
+            m_header.setAdditionalCount((quint16) m_additionalRecords.length());
+        }
     }
 }

src/modules/dns-base/src/QDnsQuery.cpp

@@ -7,86 +7,88 @@
 
 namespace QDns
 {
-
-    QDnsQuery::QDnsQuery()
-        : m_isValid(true)
-        , m_type(0)
-        , m_class(0)
-    {
-    }
-
-    QDnsQuery QDnsQuery::parse(const QByteArray& packetData, quint32 pos)
-    {
-        QDataStream dataStream(packetData);
-        dataStream.skipRawData(pos);
-        return parse(packetData, dataStream);
-    }
-
-    QDnsQuery QDnsQuery::parse(const QByteArray& packetData, QDataStream& dataStream)
+    namespace Base
     {
-        QDnsQuery query;
-
-        query.m_name = QDnsLabel::parse(packetData, dataStream);
-        if (query.m_name.isNull() || dataStream.device()->bytesAvailable() < 4)
+        QDnsQuery::QDnsQuery()
+                : m_isValid(true)
+                  , m_type(0)
+                  , m_class(0)
         {
-            query.m_isValid = false;
         }
-        else
+
+        QDnsQuery QDnsQuery::parse(const QByteArray &packetData, quint32 pos)
         {
-            dataStream >> query.m_type;
-            dataStream >> query.m_class;
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            return parse(packetData, dataStream);
         }
 
-        return query;
-    }
+        QDnsQuery QDnsQuery::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            QDnsQuery query;
+
+            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 byteArray;
-        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
-        serialize(dataStream);
-        return byteArray;
-    }
+        QByteArray QDnsQuery::serialize() const
+        {
+            QByteArray byteArray;
+            QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
+            serialize(dataStream);
+            return byteArray;
+        }
 
-    void QDnsQuery::serialize(QDataStream& dataStream) const
-    {
-        QDnsLabel::serialize(m_name, dataStream);
-        dataStream << m_type;
-        dataStream << m_class;
-    }
+        void QDnsQuery::serialize(QDataStream &dataStream) const
+        {
+            QDnsLabel::serialize(m_name, dataStream);
+            dataStream << m_type;
+            dataStream << m_class;
+        }
 
-    bool QDnsQuery::isValid() const
-    {
-        return m_isValid;
-    }
+        bool QDnsQuery::isValid() const
+        {
+            return m_isValid;
+        }
 
-    const QString& QDnsQuery::getName() const
-    {
-        return m_name;
-    }
+        const QString &QDnsQuery::getName() const
+        {
+            return m_name;
+        }
 
-    void QDnsQuery::setName(const QString& name)
-    {
-        m_name = name;
-    }
+        void QDnsQuery::setName(const QString &name)
+        {
+            m_name = name;
+        }
 
-    quint16 QDnsQuery::getType() const
-    {
-        return m_type;
-    }
+        quint16 QDnsQuery::getType() const
+        {
+            return m_type;
+        }
 
-    void QDnsQuery::setType(quint16 type)
-    {
-        m_type = type;
-    }
+        void QDnsQuery::setType(quint16 type)
+        {
+            m_type = type;
+        }
 
-    quint16 QDnsQuery::getClass() const
-    {
-        return m_class;
-    }
+        quint16 QDnsQuery::getClass() const
+        {
+            return m_class;
+        }
 
-    void QDnsQuery::setClass(quint16 aClass)
-    {
-        m_class = aClass;
+        void QDnsQuery::setClass(quint16 aClass)
+        {
+            m_class = aClass;
+        }
     }
 }

src/modules/dns-base/src/QDnsResourceRecord.cpp

@@ -7,120 +7,122 @@
 
 namespace QDns
 {
-
-    QDnsResourceRecord::QDnsResourceRecord()
-        : m_isValid(true)
-    {
-    }
-
-    QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray& packetData, quint32 pos)
+    namespace Base
     {
-        QDataStream dataStream(packetData);
-        dataStream.skipRawData(pos);
-        return parse(packetData, dataStream);
-    }
-
-    QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray& packetData, QDataStream& dataStream)
-    {
-        QDnsResourceRecord rr;
+        QDnsResourceRecord::QDnsResourceRecord()
+                : m_isValid(true)
+        {
+        }
 
-        rr.m_name = QDnsLabel::parse(packetData, dataStream);
-        if (rr.m_name.isNull() || dataStream.device()->bytesAvailable() < 10)
+        QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray &packetData, quint32 pos)
         {
-            rr.m_isValid = false;
+            QDataStream dataStream(packetData);
+            dataStream.skipRawData(pos);
+            return parse(packetData, dataStream);
         }
-        else
+
+        QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray &packetData, QDataStream &dataStream)
         {
-            dataStream >> rr.m_type;
-            dataStream >> rr.m_class;
-            dataStream >> rr.m_ttl;
-            quint16 length;
-            dataStream >> length;
-            if (dataStream.device()->bytesAvailable() < length)
+            QDnsResourceRecord rr;
+
+            rr.m_name = QDnsLabel::parse(packetData, dataStream);
+            if (rr.m_name.isNull() || dataStream.device()->bytesAvailable() < 10)
             {
                 rr.m_isValid = false;
             }
             else
             {
-                char data[length];
-                dataStream.readRawData(data, length);
-                rr.m_data.append(data, length);
+                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;
         }
-        return rr;
-    }
 
-    QByteArray QDnsResourceRecord::serialize() const
-    {
-        QByteArray byteArray;
-        QDataStream dataStream(&byteArray, QIODevice::WriteOnly);
-        serialize(dataStream);
-        return byteArray;
-    }
+        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());
-    }
+        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;
-    }
+        bool QDnsResourceRecord::isValid() const
+        {
+            return m_isValid;
+        }
 
-    const QString& QDnsResourceRecord::getName() const
-    {
-        return m_name;
-    }
+        const QString &QDnsResourceRecord::getName() const
+        {
+            return m_name;
+        }
 
-    void QDnsResourceRecord::setName(const QString& name)
-    {
-        m_name = name;
-    }
+        void QDnsResourceRecord::setName(const QString &name)
+        {
+            m_name = name;
+        }
 
-    quint16 QDnsResourceRecord::getType() const
-    {
-        return m_type;
-    }
+        quint16 QDnsResourceRecord::getType() const
+        {
+            return m_type;
+        }
 
-    void QDnsResourceRecord::setType(quint16 type)
-    {
-        m_type = type;
-    }
+        void QDnsResourceRecord::setType(quint16 type)
+        {
+            m_type = type;
+        }
 
-    quint16 QDnsResourceRecord::getClass() const
-    {
-        return m_class;
-    }
+        quint16 QDnsResourceRecord::getClass() const
+        {
+            return m_class;
+        }
 
-    void QDnsResourceRecord::setClass(quint16 aClass)
-    {
-        m_class = aClass;
-    }
+        void QDnsResourceRecord::setClass(quint16 aClass)
+        {
+            m_class = aClass;
+        }
 
-    quint32 QDnsResourceRecord::getTtl() const
-    {
-        return m_ttl;
-    }
+        quint32 QDnsResourceRecord::getTtl() const
+        {
+            return m_ttl;
+        }
 
-    void QDnsResourceRecord::setTtl(quint32 ttl)
-    {
-        m_ttl = ttl;
-    }
+        void QDnsResourceRecord::setTtl(quint32 ttl)
+        {
+            m_ttl = ttl;
+        }
 
-    const QByteArray& QDnsResourceRecord::getData() const
-    {
-        return m_data;
-    }
+        const QByteArray &QDnsResourceRecord::getData() const
+        {
+            return m_data;
+        }
 
-    void QDnsResourceRecord::setData(const QByteArray& data)
-    {
-        m_data = data;
+        void QDnsResourceRecord::setData(const QByteArray &data)
+        {
+            m_data = data;
+        }
     }
 }

src/modules/dns-base/tests/DnsHeader.cpp

@@ -40,7 +40,7 @@ TEST_P(DnsHeaderTest, parseAndGetters)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto header = QDns::QDnsHeader::parse(data);
+    auto header = QDns::Base::QDnsHeader::parse(data);
     ASSERT_EQ(header.isValid(), params.isValid);
 
     if (header.isValid())
@@ -77,7 +77,7 @@ TEST_P(DnsHeaderTest, settersAndGetters1)
     }
 
     auto data = QByteArray::fromHex(params.hexData);
-    QDns::QDnsHeader header;
+    QDns::Base::QDnsHeader header;
 
     header.setId(params.id);
     header.setFlags(params.flags);
@@ -117,7 +117,7 @@ TEST_P(DnsHeaderTest, settersAndGetters2)
     }
 
     auto data = QByteArray::fromHex(params.hexData);
-    QDns::QDnsHeader header;
+    QDns::Base::QDnsHeader header;
 
     header.setId(params.id);
     header.setIsQuery(params.flagQuery);
@@ -247,7 +247,7 @@ INSTANTIATE_TEST_CASE_P(DnsHeaderTestInst,
 
 TEST(DnsHeaderTest, getFlagBits)
 {
-    QDns::QDnsHeader header;
+    QDns::Base::QDnsHeader header;
 
     header.setFlags(0x5555);
     ASSERT_EQ(header.getFlagBits(0, 1), 0);
@@ -256,8 +256,8 @@ TEST(DnsHeaderTest, getFlagBits)
 
 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);
+    ASSERT_EQ(QDns::Base::QDnsHeader::getFlagBitIndex(0), 15);
+    ASSERT_EQ(QDns::Base::QDnsHeader::getFlagBitIndex(1), 14);
+    ASSERT_EQ(QDns::Base::QDnsHeader::getFlagBitIndex(14), 1);
+    ASSERT_EQ(QDns::Base::QDnsHeader::getFlagBitIndex(15), 0);
 }

src/modules/dns-base/tests/DnsLabel.cpp

@@ -24,7 +24,7 @@ TEST_P(DnsLabelParseTest, parse)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto label = QDns::QDnsLabel::parse(data, params.pos);
+    auto label = QDns::Base::QDnsLabel::parse(data, params.pos);
     if (params.isValid)
     {
         ASSERT_FALSE(label.isNull());
@@ -99,7 +99,7 @@ class DnsLabelSerializeTest : public ::testing::TestWithParam<DnsLabelSerializeT
 TEST_P(DnsLabelSerializeTest, parse)
 {
     auto params = GetParam();
-    auto label = QDns::QDnsLabel::serialize(params.label);
+    auto label = QDns::Base::QDnsLabel::serialize(params.label);
     auto data = QByteArray::fromHex(params.hexData);
     ASSERT_EQ(label, data);
 }

src/modules/dns-base/tests/DnsPacket.cpp

@@ -22,7 +22,7 @@ TEST_P(DnsPacketParseTest, parse)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto packet = QDns::QDnsPacket::parse(data);
+    auto packet = QDns::Base::QDnsPacket::parse(data);
 
     ASSERT_EQ(packet.isValid(), params.isValid);
 
@@ -60,7 +60,7 @@ TEST_P(DnsPacketSerializeTest, parse)
 {
     auto params = GetParam();
     auto data1 = QByteArray::fromHex(params.hexData1);
-    auto packet = QDns::QDnsPacket::parse(data1);
+    auto packet = QDns::Base::QDnsPacket::parse(data1);
 
     // TODO improve tests
     ASSERT_EQ(packet.serialize().toHex(), QString(params.hexData2).remove(" "));

src/modules/dns-base/tests/DnsQuery.cpp

@@ -26,7 +26,7 @@ TEST_P(DnsQueryParseTest, parse)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto query = QDns::QDnsQuery::parse(data, params.pos);
+    auto query = QDns::Base::QDnsQuery::parse(data, params.pos);
 
     ASSERT_EQ(query.isValid(), params.isValid);
 
@@ -84,7 +84,7 @@ class DnsQuerySerializeTest : public ::testing::TestWithParam<DnsQuerySerializeT
 TEST_P(DnsQuerySerializeTest, serialize)
 {
     auto params = GetParam();
-    QDns::QDnsQuery query;
+    QDns::Base::QDnsQuery query;
 
     query.setName(params.name);
     query.setType(params.type);

src/modules/dns-base/tests/DnsResourceRecord.cpp

@@ -28,7 +28,7 @@ TEST_P(DnsResourceRecordParseTest, parse)
 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto rr = QDns::QDnsResourceRecord::parse(data, params.pos);
+    auto rr = QDns::Base::QDnsResourceRecord::parse(data, params.pos);
 
     ASSERT_EQ(rr.isValid(), params.isValid);
 
@@ -94,7 +94,7 @@ class DnsResourceRecordSerializeTest : public ::testing::TestWithParam<DnsResour
 TEST_P(DnsResourceRecordSerializeTest, serialize)
 {
     auto params = GetParam();
-    QDns::QDnsResourceRecord rr;
+    QDns::Base::QDnsResourceRecord rr;
 
     rr.setName(params.name);
     rr.setType(params.type);