DnsResourceData.h

Go to the documentation of this file.

#pragma once
 
#include "DeprecationUtils.h"
#include "DnsResource.h"
#include "IpAddress.h"
#include <memory>
#include <string>
#include <vector>
#include <stdint.h>
 
 
namespace pcpp
{
    // forward declarations
    class IDnsResource;
 
    class IDnsResourceData
    {
    protected:
        // unimplemented private copy c'tor
        IDnsResourceData(const IDnsResourceData& other);
        IDnsResourceData()
        {}
 
        size_t decodeName(const char* encodedName, char* result, IDnsResource* dnsResource) const;
        void encodeName(const std::string& decodedName, char* result, size_t& resultLen,
                        IDnsResource* dnsResource) const;
 
    public:
        virtual ~IDnsResourceData() = default;
 
        template <class IDnsResourceDataType> bool isTypeOf() const
        {
            return dynamic_cast<const IDnsResourceDataType*>(this) != nullptr;
        }
 
        template <class IDnsResourceDataType> IDnsResourceDataType* castAs()
        {
            return dynamic_cast<IDnsResourceDataType*>(this);
        }
 
        virtual std::string toString() const = 0;
 
        virtual std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const = 0;
 
        PCPP_DEPRECATED("Use toBytes() instead")
        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;
    };
 
    class DnsResourceDataPtr : public std::unique_ptr<IDnsResourceData>
    {
    public:
        explicit DnsResourceDataPtr(IDnsResourceData* ptr) : std::unique_ptr<IDnsResourceData>(ptr)
        {}
 
        template <class IDnsResourceDataType> bool isTypeOf() const
        {
            return get()->isTypeOf<IDnsResourceDataType>();
        }
 
        template <class IDnsResourceDataType> IDnsResourceDataType* castAs()
        {
            return get()->castAs<IDnsResourceDataType>();
        }
    };
 
    class StringDnsResourceData : public IDnsResourceData
    {
    private:
        std::string m_Data;
 
    public:
        explicit StringDnsResourceData(const std::string& data) : m_Data(data)
        {}
 
        StringDnsResourceData(const uint8_t* dataPtr, size_t dataLen, IDnsResource* dnsResource);
 
        ~StringDnsResourceData() override = default;
 
        bool operator==(const StringDnsResourceData& other) const
        {
            return m_Data == other.m_Data;
        }
 
        // implement abstract methods
 
        std::string toString() const override
        {
            return m_Data;
        }
        std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const override;
    };
 
    class IPv4DnsResourceData : public IDnsResourceData
    {
    private:
        IPv4Address m_Data;
 
    public:
        IPv4DnsResourceData(const uint8_t* dataPtr, size_t dataLen);
 
        explicit IPv4DnsResourceData(const IPv4Address& addr) : m_Data(addr)
        {}
 
        explicit IPv4DnsResourceData(const std::string& addrAsString) : m_Data(addrAsString)
        {}
 
        bool operator==(const IPv4DnsResourceData& other) const
        {
            return m_Data == other.m_Data;
        }
 
        IPv4Address getIpAddress() const
        {
            return m_Data;
        }
 
        // implement abstract methods
 
        std::string toString() const override
        {
            return m_Data.toString();
        }
        std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const override;
    };
 
    class IPv6DnsResourceData : public IDnsResourceData
    {
    private:
        IPv6Address m_Data;
 
    public:
        IPv6DnsResourceData(const uint8_t* dataPtr, size_t dataLen);
 
        explicit IPv6DnsResourceData(const IPv6Address& addr) : m_Data(addr)
        {}
 
        explicit IPv6DnsResourceData(const std::string& addrAsString) : m_Data(addrAsString)
        {}
 
        bool operator==(const IPv6DnsResourceData& other) const
        {
            return m_Data == other.m_Data;
        }
 
        IPv6Address getIpAddress() const
        {
            return m_Data;
        }
 
        // implement abstract methods
 
        std::string toString() const override
        {
            return m_Data.toString();
        }
        std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const override;
    };
 
    class MxDnsResourceData : public IDnsResourceData
    {
    public:
        struct MxData
        {
            uint16_t preference = 0;
            std::string mailExchange;
        };
 
        MxDnsResourceData(uint8_t* dataPtr, size_t dataLen, IDnsResource* dnsResource);
 
        MxDnsResourceData(uint16_t preference, const std::string& mailExchange);
 
        ~MxDnsResourceData() override = default;
 
        bool operator==(const MxDnsResourceData& other) const;
 
        MxData getMxData() const
        {
            return m_Data;
        }
 
        void setMxData(uint16_t preference, std::string mailExchange);
 
        // implement abstract methods
 
        std::string toString() const override;
 
        std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const override;
 
    private:
        MxData m_Data;
    };
 
    class GenericDnsResourceData : public IDnsResourceData
    {
    private:
        uint8_t* m_Data;
        size_t m_DataLen;
 
    public:
        GenericDnsResourceData(const uint8_t* dataPtr, size_t dataLen);
 
        explicit GenericDnsResourceData(const std::string& dataAsHexString);
 
        GenericDnsResourceData(const GenericDnsResourceData& other);
 
        ~GenericDnsResourceData() override
        {
            if (m_Data != nullptr)
                delete[] m_Data;
        }
 
        GenericDnsResourceData& operator=(const GenericDnsResourceData& other);
 
        bool operator==(const GenericDnsResourceData& other) const;
 
        // implement abstract methods
 
        std::string toString() const override;
        std::vector<uint8_t> toBytes(IDnsResource* dnsResource) const override;
    };
 
}  // namespace pcpp