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"
#include <vector>
#include <map>
#if defined(WIN32) || defined(WINx64) || defined(PCAPPP_MINGW_ENV)
#include <winsock2.h>
#elif LINUX
#include <in.h>
#endif


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

        inline dnshdr* getDnsHeader() { return (dnshdr*)m_Data; }

        DnsQuery* getQuery(const std::string& name, bool exactMatch);

        DnsQuery* getFirstQuery();

        DnsQuery* getNextQuery(DnsQuery* query);

        size_t getQueryCount();

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

        DnsResource* getFirstAnswer();

        DnsResource* getNextAnswer(DnsResource* answer);

        size_t getAnswerCount();

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

        DnsResource* getFirstAuthority();

        DnsResource* getNextAuthority(DnsResource* authority);

        size_t getAuthorityCount();

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

        DnsResource* getFirstAdditionalRecord();

        DnsResource* getNextAdditionalRecord(DnsResource* additionalRecord);

        size_t getAdditionalRecordCount();

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

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

        void computeCalculateFields() {}

        std::string toString();

        OsiModelLayer getOsiModelLayer() { return OsiModelApplicationLayer; }

        static const std::map<uint16_t, bool>* getDNSPortMap();
    private:
        IDnsResource*   m_ResourceList;
        DnsQuery*       m_FirstQuery;
        DnsResource*    m_FirstAnswer;
        DnsResource*    m_FirstAuthority;
        DnsResource*    m_FirstAdditional;

        IDnsResource* getFirstResource(DnsResourceType resType);
        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);

        void parseResources();

        DnsResource* addResource(DnsResourceType resType, const std::string& name, DnsType dnsType, DnsClass dnsClass,
                uint32_t ttl, IDnsResourceData* data);

        bool removeResource(IDnsResource* resourceToRemove);

    };

} // namespace pcpp

#endif /* PACKETPP_DNS_LAYER */