DnsLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_DNS_LAYER
#define PACKETPP_DNS_LAYER

#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);

        virtual ~DnsLayer();

        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() {}

        size_t getHeaderLen() const { return m_DataLen; } //No layer above DNS

        virtual void computeCalculateFields() {}

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { 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();
    };


    // 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

#endif /* PACKETPP_DNS_LAYER */