DnsResource.h

Go to the documentation of this file.

#ifndef PACKETPP_DNS_RESOURCE
#define PACKETPP_DNS_RESOURCE

#include "DnsLayer.h"
#include "DnsLayerEnums.h"
#include "DnsResourceData.h"
#include <stdio.h>
#include <string>
#include <stdint.h>


namespace pcpp
{
    // forward declarations
    class DnsLayer;
    class IDnsResourceData;
    class DnsResourceDataPtr;


    class IDnsResource
    {
    protected:
        friend class DnsLayer;
        friend class IDnsResourceData;

    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:

        virtual ~IDnsResource() {}

        DnsType getDnsType();

        void setDnsType(DnsType newType);

        DnsClass getDnsClass();

        void setDnsClass(DnsClass newClass);

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

        size_t getNameOffset() { return m_OffsetInLayer; }

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


        // abstract methods

        virtual size_t getSize() = 0;

        virtual DnsResourceType 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 DnsResourceType getType() { return DnsQueryType; }
    };


    class DnsResource : public IDnsResource
    {
        friend class DnsLayer;

    private:
        DnsResourceType m_ResourceType;

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

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

    public:
        virtual ~DnsResource() {}

        uint32_t getTTL();

        void setTTL(uint32_t newTTL);

        size_t getDataLength();

        DnsResourceDataPtr getData();

        size_t getDataOffset();

        bool setData(IDnsResourceData* data);

        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 DnsResourceType getType() { return m_ResourceType; }

    };

}

#endif // PACKETPP_DNS_RESOURCE