DnsLayer.h

Go to the documentation of this file.

#pragma once
 
#include "DnsLayerEnums.h"
#include "DnsResource.h"
#include "DnsResourceData.h"
#include "Layer.h"
 
 
namespace pcpp
{
 
#pragma pack(push, 1)
    struct dnshdr
    {
        uint16_t transactionID;
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint16_t
            recursionDesired : 1,
            truncation : 1,
            authoritativeAnswer : 1,
            opcode : 4,
            queryOrResponse : 1,
            responseCode : 4,
            checkingDisabled : 1,
            authenticData : 1,
            zero : 1,
            recursionAvailable : 1;
#elif (BYTE_ORDER == BIG_ENDIAN)
        uint16_t
            queryOrResponse : 1,
            opcode : 4,
            authoritativeAnswer : 1,
            truncation : 1,
            recursionDesired : 1,
            recursionAvailable : 1,
            zero : 1,
            authenticData : 1,
            checkingDisabled : 1,
            responseCode : 4;
#endif
        uint16_t numberOfQuestions;
        uint16_t numberOfAnswers;
        uint16_t numberOfAuthority;
        uint16_t numberOfAdditional;
    };
#pragma pack(pop)
 
    // forward declarations
    class DnsQuery;
    class IDnsResource;
    class DnsResource;
    class IDnsResourceData;
 
    class DnsLayer : public Layer
    {
        friend class IDnsResource;
        friend class DnsQuery;
        friend class DnsResource;
 
    public:
        DnsLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DnsLayer();
 
        DnsLayer(const DnsLayer& other);
 
        DnsLayer& operator=(const DnsLayer& other);
 
        ~DnsLayer() override;
 
        dnshdr* getDnsHeader() const;
 
        DnsQuery* getQuery(const std::string& name, bool exactMatch) const;
 
        DnsQuery* getFirstQuery() const;
 
        DnsQuery* getNextQuery(DnsQuery* query) const;
 
        size_t getQueryCount() const;
 
        DnsQuery* addQuery(const std::string& name, DnsType dnsType, DnsClass dnsClass);
 
        DnsQuery* addQuery(DnsQuery* const copyQuery);
 
        bool removeQuery(const std::string& queryNameToRemove, bool exactMatch);
 
        bool removeQuery(DnsQuery* queryToRemove);
 
        DnsResource* getAnswer(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAnswer() const;
 
        DnsResource* getNextAnswer(DnsResource* answer) const;
 
        size_t getAnswerCount() const;
 
        DnsResource* addAnswer(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl,
                               IDnsResourceData* data);
 
        DnsResource* addAnswer(DnsResource* const copyAnswer);
 
        bool removeAnswer(const std::string& answerNameToRemove, bool exactMatch);
 
        bool removeAnswer(DnsResource* answerToRemove);
 
        DnsResource* getAuthority(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAuthority() const;
 
        DnsResource* getNextAuthority(DnsResource* authority) const;
 
        size_t getAuthorityCount() const;
 
        DnsResource* addAuthority(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl,
                                  IDnsResourceData* data);
 
        DnsResource* addAuthority(DnsResource* const copyAuthority);
 
        bool removeAuthority(const std::string& authorityNameToRemove, bool exactMatch);
 
        bool removeAuthority(DnsResource* authorityToRemove);
 
        DnsResource* getAdditionalRecord(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAdditionalRecord() const;
 
        DnsResource* getNextAdditionalRecord(DnsResource* additionalRecord) const;
 
        size_t getAdditionalRecordCount() const;
 
        DnsResource* addAdditionalRecord(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl,
                                         IDnsResourceData* data);
 
        DnsResource* addAdditionalRecord(const std::string& name, DnsType dnsType, uint16_t customData1,
                                         uint32_t customData2, IDnsResourceData* data);
 
        DnsResource* addAdditionalRecord(DnsResource* const copyAdditionalRecord);
 
        bool removeAdditionalRecord(const std::string& additionalRecordNameToRemove, bool exactMatch);
 
        bool removeAdditionalRecord(DnsResource* additionalRecordToRemove);
 
        // implement abstract methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }  // No layer above DNS
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
        static inline bool isDnsPort(uint16_t port);
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen, bool dnsOverTcp = false);
 
    protected:
        DnsLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, size_t offsetAdjustment);
        explicit DnsLayer(size_t offsetAdjustment);
 
    private:
        IDnsResource* m_ResourceList;
        DnsQuery* m_FirstQuery;
        DnsResource* m_FirstAnswer;
        DnsResource* m_FirstAuthority;
        DnsResource* m_FirstAdditional;
        uint16_t m_OffsetAdjustment;
 
        size_t getBasicHeaderSize();
        void init(size_t offsetAdjustment, bool callParseResource);
        void initNewLayer(size_t offsetAdjustment);
 
        IDnsResource* getFirstResource(DnsResourceType resType) const;
        void setFirstResource(DnsResourceType resType, IDnsResource* resource);
 
        using Layer::extendLayer;
        bool extendLayer(int offsetInLayer, size_t numOfBytesToExtend, IDnsResource* resource);
 
        using Layer::shortenLayer;
        bool shortenLayer(int offsetInLayer, size_t numOfBytesToShorten, IDnsResource* resource);
 
        IDnsResource* getResourceByName(IDnsResource* startFrom, size_t resourceCount, const std::string& name,
                                        bool exactMatch) const;
 
        void parseResources();
 
        DnsResource* addResource(DnsResourceType resType, const std::string& name, DnsType dnsType, DnsClass dnsClass,
                                 uint32_t ttl, IDnsResourceData* data);
 
        bool removeResource(IDnsResource* resourceToRemove);
    };
 
    class DnsOverTcpLayer : public DnsLayer
    {
    public:
        DnsOverTcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : DnsLayer(data, dataLen, prevLayer, packet, sizeof(uint16_t))
        {}
 
        DnsOverTcpLayer() : DnsLayer(sizeof(uint16_t))
        {}
 
        DnsOverTcpLayer(const DnsOverTcpLayer& other) : DnsLayer(other)
        {}
 
        uint16_t getTcpMessageLength();
 
        void setTcpMessageLength(uint16_t value);
 
        // overridden methods
 
        void computeCalculateFields() override;
    };
 
    // implementation of inline methods
 
    bool DnsLayer::isDnsPort(uint16_t port)
    {
        switch (port)
        {
        case 53:
        case 5353:
        case 5355:
            return true;
        default:
            return false;
        }
    }
 
    bool DnsLayer::isDataValid(const uint8_t* data, size_t dataLen, bool dnsOverTcp)
    {
        size_t minSize = sizeof(dnshdr) + (dnsOverTcp ? sizeof(uint16_t) : 0);
        return data && dataLen >= minSize;
    }
 
}  // namespace pcpp