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);
 
        IDnsResource* getNextResource() const { return m_NextResource; }
        void setNexResource(IDnsResource* next) { m_NextResource = next; }
 
        uint8_t* getRawData() const;
 
        void setDnsLayer(DnsLayer* dnsLayer, size_t offsetInLayer);
 
    public:
 
        virtual ~IDnsResource() {}
 
        DnsType getDnsType() const;
 
        void setDnsType(DnsType newType);
 
        DnsClass getDnsClass() const;
 
        void setDnsClass(DnsClass newClass);
 
        std::string getName() const { return m_DecodedName; }
 
        size_t getNameOffset() const { return m_OffsetInLayer; }
 
        bool setName(const std::string& newName);
 
 
        // abstract methods
 
        virtual size_t getSize() const = 0;
 
        virtual DnsResourceType getType() const = 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() {}
 
        // implementation of abstract methods
        virtual size_t getSize() const { return m_NameLength + 2*sizeof(uint16_t); }
        virtual DnsResourceType getType() const { 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() const;
 
        void setTTL(uint32_t newTTL);
 
        size_t getDataLength() const;
 
        DnsResourceDataPtr getData() const;
 
        size_t getDataOffset() const;
 
        bool setData(IDnsResourceData* data);
 
        uint16_t getCustomDnsClass() const;
 
        void setCustomDnsClass(uint16_t customValue);
 
        // implementation of abstract methods
        virtual size_t getSize() const { return m_NameLength + 3*sizeof(uint16_t) + sizeof(uint32_t) + getDataLength(); }
        virtual DnsResourceType getType() const { return m_ResourceType; }
 
    };
 
}
 
#endif // PACKETPP_DNS_RESOURCE