DnsLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_DNS_LAYER
#define PACKETPP_DNS_LAYER

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


    enum DnsType
    {
        DNS_TYPE_A = 1,
        DNS_TYPE_NS,
        DNS_TYPE_MD,
        DNS_TYPE_MF,
        DNS_TYPE_CNAME,
        DNS_TYPE_SOA,
        DNS_TYPE_MB,
        DNS_TYPE_MG,
        DNS_TYPE_MR,
        DNS_TYPE_NULL_R,
        DNS_TYPE_WKS,
        DNS_TYPE_PTR,
        DNS_TYPE_HINFO,
        DNS_TYPE_MINFO,
        DNS_TYPE_MX,
        DNS_TYPE_TXT,
        DNS_TYPE_RP,
        DNS_TYPE_AFSDB,
        DNS_TYPE_X25,
        DNS_TYPE_ISDN,
        DNS_TYPE_RT,
        DNS_TYPE_NSAP,
        DNS_TYPE_NSAP_PTR,
        DNS_TYPE_SIG,
        DNS_TYPE_KEY,
        DNS_TYPE_PX,
        DNS_TYPE_GPOS,
        DNS_TYPE_AAAA,
        DNS_TYPE_LOC,
        DNS_TYPE_NXT,
        DNS_TYPE_EID,
        DNS_TYPE_NIMLOC,
        DNS_TYPE_SRV,
        DNS_TYPE_ATMA,
        DNS_TYPE_NAPTR,
        DNS_TYPE_KX,
        DNS_TYPE_CERT,
        DNS_TYPE_A6,
        DNS_TYPE_DNAM,
        DNS_TYPE_SINK,
        DNS_TYPE_OPT,
        DNS_TYPE_APL,
        DNS_TYPE_DS,
        DNS_TYPE_SSHFP,
        DNS_TYPE_IPSECKEY,
        DNS_TYPE_RRSIG,
        DNS_TYPE_NSEC,
        DNS_TYPE_DNSKEY,
        DNS_TYPE_DHCID,
        DNS_TYPE_NSEC3,
        DNS_TYPE_NSEC3PARAM,
        DNS_TYPE_ALL = 255
    };


    enum DnsClass
    {
        DNS_CLASS_IN = 1,
        DNS_CLASS_IN_QU = 32769,
        DNS_CLASS_CH = 3,
        DNS_CLASS_HS = 4,
        DNS_CLASS_ANY = 255
    };


    class DnsLayer;


    class IDnsResource
    {
    protected:
        friend class DnsLayer;

    protected:
        DnsLayer* m_DnsLayer;
        size_t m_OffsetInLayer;
        IDnsResource* m_NextResource;
        std::string m_DecodedName;
        size_t m_NameLength;
        uint8_t* m_ExternalRawData;

        IDnsResource(DnsLayer* dnsLayer, size_t offsetInLayer);

        IDnsResource(uint8_t* emptyRawData);

        size_t decodeName(const char* encodedName, char* result, int iteration = 1);
        void encodeName(const std::string& decodedName, char* result, size_t& resultLen);

        inline IDnsResource* getNextResource() { return m_NextResource; }
        inline void setNexResource(IDnsResource* next) { m_NextResource = next; }

        uint8_t* getRawData();

        void setDnsLayer(DnsLayer* dnsLayer, size_t offsetInLayer);

    public:
        enum ResourceType
        {
            DnsQuery = 0,
            DnsAnswer = 1,
            DnsAuthority = 2,
            DnsAdditional = 3
        };

        virtual ~IDnsResource() {}

        DnsType getDnsType();

        void setDnsType(DnsType newType);

        DnsClass getDnsClass();

        void setDnsClass(DnsClass newClass);

        std::string getName() { return m_DecodedName; }

        bool setName(const std::string& newName);


        // abstract methods

        virtual size_t getSize() = 0;

        virtual ResourceType getType() = 0;
    };


    class DnsQuery : public IDnsResource
    {
        friend class DnsLayer;

    private:
        DnsQuery(DnsLayer* dnsLayer, size_t offsetInLayer) : IDnsResource(dnsLayer, offsetInLayer) {}

        DnsQuery(uint8_t* emptyRawData) : IDnsResource(emptyRawData) {}

    public:
        virtual ~DnsQuery() {}

        // abstract methods
        virtual size_t getSize() { return m_NameLength + 2*sizeof(uint16_t); }
        virtual ResourceType getType() { return IDnsResource::DnsQuery; }
    };


    class DnsResource : public IDnsResource
    {
        friend class DnsLayer;

    private:
        ResourceType m_ResourceType;

        DnsResource(DnsLayer* dnsLayer, size_t offsetInLayer, ResourceType resourceType) : IDnsResource(dnsLayer, offsetInLayer) { m_ResourceType = resourceType; }

        DnsResource(uint8_t* emptyRawData, ResourceType resType) : IDnsResource(emptyRawData), m_ResourceType(resType) {}

    public:
        virtual ~DnsResource() {}

        uint32_t getTTL();

        void setTTL(uint32_t newTTL);

        size_t getDataLength();

        std::string getDataAsString();

        bool setData(const std::string& dataAsString);

        uint16_t getCustomDnsClass();

        void setCustomDnsClass(uint16_t customValue);

        // abstract methods
        virtual size_t getSize() { return m_NameLength + 3*sizeof(uint16_t) + sizeof(uint32_t) + getDataLength(); }
        virtual ResourceType getType() { return m_ResourceType; }

    };


    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, const std::string& 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, const std::string& 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, const std::string& data);

        DnsResource* addAdditionalRecord(const std::string& name, DnsType dnsType, uint16_t customData1, uint32_t customData2, const std::string& 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(IDnsResource::ResourceType resType);
        void setFirstResource(IDnsResource::ResourceType 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(IDnsResource::ResourceType resType, const std::string& name, DnsType dnsType, DnsClass dnsClass,
                uint32_t ttl, const std::string& data);

        bool removeResource(IDnsResource* resourceToRemove);

    };

} // namespace pcpp

#endif /* PACKETPP_DNS_LAYER */