Added toString methods and qDebug support

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

 #include <qplatformdefs.h>
 #include <QByteArray>
 #include <QDataStream>
+#include <QDebug>
 #include "QDnsBase.h"
 
 namespace QDns
 
             void setAdditionalCount(quint16 additionalCount);
 
+            QString toString() const;
+
         private:
             void parse(QDataStream &dataStream);
 
             quint16 m_authorityCount;
             quint16 m_additionalCount;
         };
+
+        QDebug operator<<(QDebug debug, const QDnsHeader &h);
     }
 }
 

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

 
             void setAdditionalRecords(const QList<QDnsResourceRecord> &additionalRecords);
 
+            QString toString() const;
+
             static QDnsPacket makeSimpleQuery(const QString& host, QDnsBase::RecordType type);
 
         private:
             QList<QDnsResourceRecord> m_authorityRecords;
             QList<QDnsResourceRecord> m_additionalRecords;
         };
+
+        QDebug operator<<(QDebug debug, const QDnsPacket &p);
     }
 }
 

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

 
             void setClass(QDnsBase::RecordClass aClass);
 
+            QString toString() const;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 
             quint16 m_type;
             quint16 m_class;
         };
+
+        QDebug operator<<(QDebug debug, const QDnsQuery &q);
     }
 }
 

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

 #include <qplatformdefs.h>
 #include <QByteArray>
 #include <QDataStream>
+#include <QDebug>
+#include "dns-base/QDnsBase.h"
 #include "dns-base/RecordData/QDnsRecordData.h"
 
 namespace QDns
 
             void setName(const QString &name);
 
-            quint16 getType() const;
+            QDnsBase::RecordType getType() const;
 
-            void setType(quint16 type);
+            void setType(QDnsBase::RecordType type);
 
-            quint16 getClass() const;
+            QDnsBase::RecordClass getClass() const;
 
-            void setClass(quint16 aClass);
+            void setClass(QDnsBase::RecordClass aClass);
 
             quint32 getTtl() const;
 
 
             void setData(QDnsRecordData* data);
 
+            QString toString() const;
+
         private:
             void copy(const QDnsResourceRecord& other);
             void parse(const QByteArray &packetData, QDataStream &dataStream);
             quint32 m_ttl;
             QScopedPointer<QDnsRecordData> m_data;
         };
+
+        QDebug operator<<(QDebug debug, const QDnsResourceRecord &rr);
     }
 }
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordData.h

 
             virtual QDnsRecordData* clone() const = 0;
 
+            virtual QString toString() const;
+
         protected:
             bool m_isValid;
         };
+
+        QDebug operator<<(QDebug debug, const QDnsRecordData &rd);
     }
 }
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataA.h

 
             void setIp(const QHostAddress &ip);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataAAAA.h

 
             void setIp(const QHostAddress &ip);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataMX.h

 
             void setMx(const QString &mx);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataPTR.h

 
             void setHostname(const QString &hostname);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataRaw.h

 
             void setData(const QByteArray &data);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

src/modules/dns-base/includes/dns-base/RecordData/QDnsRecordDataSOA.h

 
             void setMinimumTtl(quint32 minimumTtl);
 
+            QString toString() const override;
+
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);
 

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

 // Created by robin on 1/7/18.
 //
 
+#include <QDebugStateSaver>
+#include <QMetaEnum>
 #include "dns-base/QDnsHeader.h"
 
 namespace QDns
         {
             m_additionalCount = additionalCount;
         }
+
+        QString QDnsHeader::toString() const
+        {
+            static int headerOpcodeId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("HeaderOpcode");
+            static int headerReplyCodeId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("HeaderReplyCode");
+            auto headerOpcodeStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(headerOpcodeId).valueToKey(getOpcode())).toUpper();
+            auto replyCodeStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(headerReplyCodeId).valueToKey(getReplyCode())).toUpper();
+            return QString(";; ->>HEADER<<- opcode: ") + headerOpcodeStr + ", status: "
+                   + replyCodeStr + ", id: " + QString::number(getId()) + "\n"
+                   + ";; flags:"
+                   + (!isQuery() ? " qr" : "")
+                   + (isAuthoritative() ? " aa" : "")
+                   + (isTruncated() ? " tc" : "")
+                   + (isRecursionDesired() ? " rd" : "")
+                   + (isRecursionAvailable() ? " ra" : "")
+                   + (isAnswerAuthenticated() ? " ad" : "")
+                   + (isNonAuthenticatedAcceptable() ? " cd" : "")
+                   + "; QUERY: " + QString::number(getQueryCount()) + ", ANSWER: " + QString::number(getAnswerCount())
+                   + ", AUTHORITY: " + QString::number(getAuthorityCount()) + ", ADDITIONAL: " + QString::number(getAdditionalCount());
+        }
+
+        QDebug operator<<(QDebug debug, const QDnsHeader &h)
+        {
+            QDebugStateSaver saver(debug);
+            debug.noquote() << h.toString();
+            return debug;
+        }
     }
 }

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

             m_header.setAdditionalCount((quint16) m_additionalRecords.length());
         }
 
+        QString QDnsPacket::toString() const
+        {
+            auto str = getHeader().toString();
+
+            if (getHeader().getQueryCount())
+            {
+                str += "\n;; QUESTION SECTION:\n";
+                for (const auto& query : getQueries())
+                {
+                    str += ";" + query.toString() + "\n";
+                }
+            }
+
+            if (getHeader().getAnswerCount())
+            {
+                str += "\n;; ANSWER SECTION:\n";
+                for (const auto& answer : getAnswerRecords())
+                {
+                    str += answer.toString() + "\n";
+                }
+            }
+
+            if (getHeader().getAuthorityCount())
+            {
+                str += "\n;; AUTHORITY SECTION:\n";
+                for (const auto& answer : getAuthorityRecords())
+                {
+                    str += answer.toString() + "\n";
+                }
+            }
+
+            if (getHeader().getAdditionalCount())
+            {
+                str += "\n;; ADDITIONAL SECTION:\n";
+                for (const auto& answer : getAdditionalRecords())
+                {
+                    str += answer.toString() + "\n";
+                }
+            }
+
+            return str;
+        }
+
         QDnsPacket QDnsPacket::makeSimpleQuery(const QString& host, QDnsBase::RecordType type)
         {
             QDns::Base::QDnsPacket packet;
             packet.setQueries(QList<QDns::Base::QDnsQuery>() << query);
             return packet;
         }
+
+        QDebug operator<<(QDebug debug, const QDnsPacket &p)
+        {
+            QDebugStateSaver saver(debug);
+            debug.noquote() << p.toString();
+            return debug;
+        }
     }
 }

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

 // Created by robin on 1/8/18.
 //
 
+#include <QDebugStateSaver>
+#include <QMetaEnum>
 #include "dns-base/QDnsLabel.h"
 #include "dns-base/QDnsQuery.h"
 
         {
             m_class = aClass;
         }
+
+        QString QDnsQuery::toString() const
+        {
+            static int recordClassId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("RecordClass");
+            static int recordTypeId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("RecordType");
+            auto recordClassStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(recordClassId).valueToKey(getClass())).toUpper();
+            auto recordTypeStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(recordTypeId).valueToKey(getType())).toUpper();
+            return getName() + "\t" + recordClassStr + "\t" + recordTypeStr;
+        }
+
+        QDebug operator<<(QDebug debug, const QDnsQuery &q)
+        {
+            QDebugStateSaver saver(debug);
+            debug.noquote() << q.toString();
+            return debug;
+        }
     }
 }

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

 // Created by robin on 1/10/18.
 //
 
+#include <QMetaEnum>
+#include "dns-base/RecordData/QDnsRecordDataA.h"
+#include "dns-base/RecordData/QDnsRecordDataAAAA.h"
+#include "dns-base/RecordData/QDnsRecordDataMX.h"
+#include "dns-base/RecordData/QDnsRecordDataPTR.h"
+#include "dns-base/RecordData/QDnsRecordDataSOA.h"
 #include "dns-base/RecordData/QDnsRecordDataRaw.h"
 #include "dns-base/QDnsLabel.h"
 #include "dns-base/QDnsResourceRecord.h"
                     dataStream.readRawData(data, length);
                     QByteArray byteArray(data, length);
                     QDataStream dataStream2(byteArray);
-                    m_data.reset(new QDnsRecordDataRaw(packetData, dataStream2));
+                    QDnsRecordData* recordData = nullptr;
+                    if (m_type == QDns::Base::QDnsBase::RecordType::A)
+                    {
+                        recordData = new QDnsRecordDataA(packetData, dataStream2);
+                    }
+                    else if (m_type == QDns::Base::QDnsBase::RecordType::AAAA)
+                    {
+                        recordData = new QDnsRecordDataAAAA(packetData, dataStream2);
+                    }
+                    else if (m_type == QDns::Base::QDnsBase::RecordType::MX)
+                    {
+                        recordData = new QDnsRecordDataMX(packetData, dataStream2);
+                    }
+                    else if (m_type == QDns::Base::QDnsBase::RecordType::PTR)
+                    {
+                        recordData = new QDnsRecordDataPTR(packetData, dataStream2);
+                    }
+                    else if (m_type == QDns::Base::QDnsBase::RecordType::SOA)
+                    {
+                        recordData = new QDnsRecordDataSOA(packetData, dataStream2);
+                    }
+                    else
+                    {
+                        recordData = new QDnsRecordDataRaw(packetData, dataStream2);
+                    }
+                    m_data.reset(recordData);
                 }
             }
         }
             m_name = name;
         }
 
-        quint16 QDnsResourceRecord::getType() const
+        QDnsBase::RecordType QDnsResourceRecord::getType() const
         {
-            return m_type;
+            return (QDnsBase::RecordType) m_type;
         }
 
-        void QDnsResourceRecord::setType(quint16 type)
+        void QDnsResourceRecord::setType(QDnsBase::RecordType type)
         {
             m_type = type;
         }
 
-        quint16 QDnsResourceRecord::getClass() const
+        QDnsBase::RecordClass QDnsResourceRecord::getClass() const
         {
-            return m_class;
+            return (QDnsBase::RecordClass) m_class;
         }
 
-        void QDnsResourceRecord::setClass(quint16 aClass)
+        void QDnsResourceRecord::setClass(QDnsBase::RecordClass aClass)
         {
             m_class = aClass;
         }
         {
             m_data.reset(data);
         }
+
+        QString QDnsResourceRecord::toString() const
+        {
+            static int recordClassId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("RecordClass");
+            static int recordTypeId = QDns::Base::QDnsBase::staticMetaObject.indexOfEnumerator("RecordType");
+            auto recordClassStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(recordClassId).valueToKey(getClass())).toUpper();
+            auto recordTypeStr = QString(QDns::Base::QDnsBase::staticMetaObject.enumerator(recordTypeId).valueToKey(getType())).toUpper();
+            return getName() + "\t" + QString::number(getTtl()) + "\t" + recordClassStr + "\t" + recordTypeStr + "\t" + getData()->toString();
+        }
+
+        QDebug operator<<(QDebug debug, const QDnsResourceRecord &rr)
+        {
+            QDebugStateSaver saver(debug);
+            debug.noquote() << rr.toString();
+            return debug;
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordData.cpp

 // Created by robin on 1/12/18.
 //
 
+#include <QDebugStateSaver>
 #include "dns-base/RecordData/QDnsRecordData.h"
 
 namespace QDns
         {
             return m_isValid;
         }
+
+        QString QDnsRecordData::toString() const
+        {
+            return "NOT_IMPLEMENTED";
+        }
+
+        QDebug operator<<(QDebug debug, const QDnsRecordData &rd)
+        {
+            QDebugStateSaver saver(debug);
+            debug.noquote().nospace() << rd.toString();
+            return debug;
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataA.cpp

         {
             m_ip = ip;
         }
+
+        QString QDnsRecordDataA::toString() const
+        {
+            return getIp().toString();
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataAAAA.cpp

         {
             m_ip = ip;
         }
+
+        QString QDnsRecordDataAAAA::toString() const
+        {
+            return getIp().toString();
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataMX.cpp

         {
             m_mx = mx;
         }
+
+        QString QDnsRecordDataMX::toString() const
+        {
+            return QString::number(getPreference()) + " " + getMx();
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataPTR.cpp

         {
             m_hostname = hostname;
         }
+
+        QString QDnsRecordDataPTR::toString() const
+        {
+            return getHostname();
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataRaw.cpp

         {
             m_data = data;
         }
+
+        QString QDnsRecordDataRaw::toString() const
+        {
+            return m_data.toHex();
+        }
     }
 }

src/modules/dns-base/src/RecordData/QDnsRecordDataSOA.cpp

         {
             m_minimumTtl = minimumTtl;
         }
+
+        QString QDnsRecordDataSOA::toString() const
+        {
+            return getPrimaryNs() + " " + getAdminMb() + " " + QString::number(getSerialNumber())
+                   + " " + QString::number(getRefreshInterval()) + " " + QString::number(getRetryInterval())
+                   + " " + QString::number(getExpirationLimit()) + " " + QString::number(getMinimumTtl());
+        }
     }
 }