Use constructors instead of static methods to parse DNS packets

src/modules/dns-base/CMakeLists.txt

         includes/dns-base/QDnsResourceRecord.h
         src/QDnsPacket.cpp
         includes/dns-base/QDnsPacket.h
-        includes/dns-base/QDnsBase.h)
+        includes/dns-base/QDnsBase.h
+        src/RecordData/QDnsRDataDecoder.cpp
+        includes/dns-base/RecordData/QDnsRDataDecoder.h src/RecordData/QDnsRDataA.cpp src/RecordData/QDnsRDataA.h)
 
 target_link_libraries(${PROJECT_NAME} Qt5::Core)
 

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

         public:
             QDnsHeader();
 
-            static QDnsHeader parse(const QByteArray &data);
+            explicit QDnsHeader(const QByteArray &data);
 
-            static QDnsHeader parse(QDataStream &dataStream);
+            explicit QDnsHeader(QDataStream &dataStream);
 
             QByteArray serialize() const;
 
             void setAdditionalCount(quint16 additionalCount);
 
         private:
+            void parse(QDataStream &dataStream);
+
             bool m_isValid;
             quint16 m_id;
             quint16 m_flags;

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

         public:
             QDnsPacket();
 
-            static QDnsPacket parse(const QByteArray &data);
+            explicit QDnsPacket(const QByteArray &data);
 
-            static QDnsPacket parse(const QByteArray &data, QDataStream &dataStream);
+            QDnsPacket(const QByteArray &data, QDataStream &dataStream);
 
             QByteArray serialize() const;
 
             void setAdditionalRecords(const QList<QDnsResourceRecord> &additionalRecords);
 
         private:
-            bool m_isValid;
+            void parse(const QByteArray &data, QDataStream &dataStream);
 
+            bool m_isValid;
             QDnsHeader m_header;
-
             QList<QDnsQuery> m_queries;
             QList<QDnsResourceRecord> m_answerRecords;
             QList<QDnsResourceRecord> m_authorityRecords;

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

         public:
             QDnsQuery();
 
-            static QDnsQuery parse(const QByteArray &packetData, quint32 pos);
+            QDnsQuery(const QByteArray &packetData, quint32 pos);
 
-            static QDnsQuery parse(const QByteArray &packetData, QDataStream &dataStream);
+            QDnsQuery(const QByteArray &packetData, QDataStream &dataStream);
 
             QByteArray serialize() const;
 
             void setClass(quint16 aClass);
 
         private:
-            bool m_isValid;
+            void parse(const QByteArray &packetData, QDataStream &dataStream);
 
+            bool m_isValid;
             QString m_name;
             quint16 m_type;
             quint16 m_class;

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

         public:
             QDnsResourceRecord();
 
-            static QDnsResourceRecord parse(const QByteArray &packetData, quint32 pos);
+            QDnsResourceRecord(const QByteArray &packetData, quint32 pos);
 
-            static QDnsResourceRecord parse(const QByteArray &packetData, QDataStream &dataStream);
+            QDnsResourceRecord(const QByteArray &packetData, QDataStream &dataStream);
 
             QByteArray serialize() const;
 
             void setData(const QByteArray &data);
 
         private:
-            bool m_isValid;
+            void parse(const QByteArray &packetData, QDataStream &dataStream);
 
+            bool m_isValid;
             QString m_name;
             quint16 m_type;
             quint16 m_class;

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

                   , m_authorityCount(0)
                   , m_additionalCount(0)
         {
-
         }
 
-        QDnsHeader QDnsHeader::parse(const QByteArray &data)
+        QDnsHeader::QDnsHeader(const QByteArray &data)
+                : QDnsHeader()
         {
             QDataStream dataStream(data);
-            return QDnsHeader::parse(dataStream);
+            parse(dataStream);
         }
 
-        QDnsHeader QDnsHeader::parse(QDataStream &dataStream)
+        QDnsHeader::QDnsHeader(QDataStream &dataStream)
+                : QDnsHeader()
+        {
+            parse(dataStream);
+        }
+        void QDnsHeader::parse(QDataStream &dataStream)
         {
-            QDnsHeader header;
-
             if (dataStream.device()->bytesAvailable() < 12)
             {
-                header.m_isValid = false;
+                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;
+                dataStream >> m_id;
+                dataStream >> m_flags;
+                dataStream >> m_queryCount;
+                dataStream >> m_answerCount;
+                dataStream >> m_authorityCount;
+                dataStream >> m_additionalCount;
             }
-
-            return header;
         }
 
         QByteArray QDnsHeader::serialize() const

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

         {
         }
 
-        QDnsPacket QDnsPacket::parse(const QByteArray &data)
+        QDnsPacket::QDnsPacket(const QByteArray &data)
+                : QDnsPacket()
         {
             QDataStream dataStream(data);
-            return parse(data, dataStream);
+            parse(data, dataStream);
         }
 
-        QDnsPacket QDnsPacket::parse(const QByteArray &data, QDataStream &dataStream)
+        QDnsPacket::QDnsPacket(const QByteArray &data, QDataStream &dataStream)
+                : QDnsPacket()
         {
-            QDnsPacket packet;
+            parse(data, dataStream);
+        }
 
-            packet.m_header = QDnsHeader::parse(dataStream);
-            if (!packet.m_header.isValid())
+        void QDnsPacket::parse(const QByteArray &data, QDataStream &dataStream)
+        {
+            m_header = QDnsHeader(dataStream);
+            if (!m_header.isValid())
             {
-                packet.m_isValid = false;
+                m_isValid = false;
             }
             else
             {
-                for (quint16 i = 0; i < packet.m_header.getQueryCount() && packet.m_isValid; ++i)
+                for (quint16 i = 0; i < m_header.getQueryCount() && m_isValid; ++i)
                 {
-                    auto entry = QDnsQuery::parse(data, dataStream);
+                    auto entry = QDnsQuery(data, dataStream);
                     if (!entry.isValid())
                     {
-                        packet.m_isValid = false;
+                        m_isValid = false;
                     }
-                    packet.m_queries.append(entry);
+                    m_queries.append(entry);
                 }
-                for (quint16 i = 0; i < packet.m_header.getAnswerCount() && packet.m_isValid; ++i)
+                for (quint16 i = 0; i < m_header.getAnswerCount() && m_isValid; ++i)
                 {
-                    auto entry = QDnsResourceRecord::parse(data, dataStream);
+                    auto entry = QDnsResourceRecord(data, dataStream);
                     if (!entry.isValid())
                     {
-                        packet.m_isValid = false;
+                        m_isValid = false;
                     }
-                    packet.m_answerRecords.append(entry);
+                    m_answerRecords.append(entry);
                 }
-                for (quint16 i = 0; i < packet.m_header.getAuthorityCount() && packet.m_isValid; ++i)
+                for (quint16 i = 0; i < m_header.getAuthorityCount() && m_isValid; ++i)
                 {
-                    auto entry = QDnsResourceRecord::parse(data, dataStream);
+                    auto entry = QDnsResourceRecord(data, dataStream);
                     if (!entry.isValid())
                     {
-                        packet.m_isValid = false;
+                        m_isValid = false;
                     }
-                    packet.m_authorityRecords.append(entry);
+                    m_authorityRecords.append(entry);
                 }
-                for (quint16 i = 0; i < packet.m_header.getAdditionalCount() && packet.m_isValid; ++i)
+                for (quint16 i = 0; i < m_header.getAdditionalCount() && m_isValid; ++i)
                 {
-                    auto entry = QDnsResourceRecord::parse(data, dataStream);
+                    auto entry = QDnsResourceRecord(data, dataStream);
                     if (!entry.isValid())
                     {
-                        packet.m_isValid = false;
+                        m_isValid = false;
                     }
-                    packet.m_additionalRecords.append(entry);
+                    m_additionalRecords.append(entry);
                 }
             }
-
-            return packet;
         }
 
         QByteArray QDnsPacket::serialize() const

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

         {
         }
 
-        QDnsQuery QDnsQuery::parse(const QByteArray &packetData, quint32 pos)
+        QDnsQuery::QDnsQuery(const QByteArray &packetData, quint32 pos)
+                : QDnsQuery()
         {
             QDataStream dataStream(packetData);
             dataStream.skipRawData(pos);
-            return parse(packetData, dataStream);
+            parse(packetData, dataStream);
         }
 
-        QDnsQuery QDnsQuery::parse(const QByteArray &packetData, QDataStream &dataStream)
+        QDnsQuery::QDnsQuery(const QByteArray &packetData, QDataStream &dataStream)
+                : QDnsQuery()
         {
-            QDnsQuery query;
+            parse(packetData, dataStream);
+        }
 
-            query.m_name = QDnsLabel::parse(packetData, dataStream);
-            if (query.m_name.isNull() || dataStream.device()->bytesAvailable() < 4)
+        void QDnsQuery::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            m_name = QDnsLabel::parse(packetData, dataStream);
+            if (m_name.isNull() || dataStream.device()->bytesAvailable() < 4)
             {
-                query.m_isValid = false;
+                m_isValid = false;
             }
             else
             {
-                dataStream >> query.m_type;
-                dataStream >> query.m_class;
+                dataStream >> m_type;
+                dataStream >> m_class;
             }
-
-            return query;
         }
 
         QByteArray QDnsQuery::serialize() const

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

         {
         }
 
-        QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray &packetData, quint32 pos)
+        QDnsResourceRecord::QDnsResourceRecord(const QByteArray &packetData, quint32 pos)
+                : QDnsResourceRecord()
         {
             QDataStream dataStream(packetData);
             dataStream.skipRawData(pos);
-            return parse(packetData, dataStream);
+            parse(packetData, dataStream);
         }
 
-        QDnsResourceRecord QDnsResourceRecord::parse(const QByteArray &packetData, QDataStream &dataStream)
+        QDnsResourceRecord::QDnsResourceRecord(const QByteArray &packetData, QDataStream &dataStream)
+                : QDnsResourceRecord()
         {
-            QDnsResourceRecord rr;
+            parse(packetData, dataStream);
+        }
 
-            rr.m_name = QDnsLabel::parse(packetData, dataStream);
-            if (rr.m_name.isNull() || dataStream.device()->bytesAvailable() < 10)
+        void QDnsResourceRecord::parse(const QByteArray &packetData, QDataStream &dataStream)
+        {
+            m_name = QDnsLabel::parse(packetData, dataStream);
+            if (m_name.isNull() || dataStream.device()->bytesAvailable() < 10)
             {
-                rr.m_isValid = false;
+                m_isValid = false;
             }
             else
             {
-                dataStream >> rr.m_type;
-                dataStream >> rr.m_class;
-                dataStream >> rr.m_ttl;
+                dataStream >> m_type;
+                dataStream >> m_class;
+                dataStream >> m_ttl;
                 quint16 length;
                 dataStream >> length;
                 if (dataStream.device()->bytesAvailable() < length)
                 {
-                    rr.m_isValid = false;
+                    m_isValid = false;
                 }
                 else
                 {
                     char data[length];
                     dataStream.readRawData(data, length);
-                    rr.m_data.append(data, length);
+                    m_data.append(data, length);
                 }
             }
-            return rr;
         }
 
         QByteArray QDnsResourceRecord::serialize() const

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

 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto header = QDns::Base::QDnsHeader::parse(data);
+    auto header = QDns::Base::QDnsHeader(data);
     ASSERT_EQ(header.isValid(), params.isValid);
 
     if (header.isValid())

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

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

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

 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto query = QDns::Base::QDnsQuery::parse(data, params.pos);
+    auto query = QDns::Base::QDnsQuery(data, params.pos);
 
     ASSERT_EQ(query.isValid(), params.isValid);
 

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

 {
     auto params = GetParam();
     auto data = QByteArray::fromHex(params.hexData);
-    auto rr = QDns::Base::QDnsResourceRecord::parse(data, params.pos);
+    auto rr = QDns::Base::QDnsResourceRecord(data, params.pos);
 
     ASSERT_EQ(rr.isValid(), params.isValid);