DnsResource.h

Go to the documentation of this file.

#pragma once
 
#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 setNextResource(IDnsResource* next)
        {
            m_NextResource = next;
        }
 
        uint8_t* getRawData() const;
 
        void setDnsLayer(DnsLayer* dnsLayer, size_t offsetInLayer);
 
    public:
        virtual ~IDnsResource() = default;
 
        DnsType getDnsType() const;
 
        void setDnsType(DnsType newType);
 
        DnsClass getDnsClass() const;
 
        void setDnsClass(DnsClass newClass);
 
        const 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)
        {}
 
        explicit DnsQuery(uint8_t* emptyRawData) : IDnsResource(emptyRawData)
        {}
 
    public:
        ~DnsQuery() override = default;
 
        // implementation of abstract methods
        size_t getSize() const override
        {
            return m_NameLength + 2 * sizeof(uint16_t);
        }
        DnsResourceType getType() const override
        {
            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:
        ~DnsResource() override = default;
 
        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
        size_t getSize() const override
        {
            return m_NameLength + 3 * sizeof(uint16_t) + sizeof(uint32_t) + getDataLength();
        }
        DnsResourceType getType() const override
        {
            return m_ResourceType;
        }
    };
 
}  // namespace pcpp