DnsResourceData.h

Go to the documentation of this file.

#ifndef PACKETPP_DNS_RESOURCE_DATA
#define PACKETPP_DNS_RESOURCE_DATA

#include "DnsResource.h"
#include "IpAddress.h"
#include <memory>
#include <string>
#include <stdint.h>


namespace pcpp
{

    //Visual studio has always been stupid about returning something useful for __cplusplus
    //Only recently was this fixed - and even then it requires a specific hack to the command line during build
    //Its easier/more consistent to test _MSC_VER in VS
    //https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=vs-2017

    #if __cplusplus > 199711L || _MSC_VER >= 1800 //Maybe this can be 1600 for VS2010
    #define PCPP_SMART_PTR(T) std::unique_ptr<T>
    #else
    #define PCPP_SMART_PTR(T) std::auto_ptr<T>
    #endif

    // 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() { }

        template <class IDnsResourceDataType>
        bool isTypeOf() const { return dynamic_cast<const IDnsResourceDataType*>(this) != NULL; }

        template <class IDnsResourceDataType>
        IDnsResourceDataType* castAs() { return dynamic_cast<IDnsResourceDataType*>(this); }

        virtual std::string toString() const = 0;

        virtual bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const = 0;
    };


    class DnsResourceDataPtr : public PCPP_SMART_PTR(IDnsResourceData)
    {
    public:

        explicit DnsResourceDataPtr(IDnsResourceData* ptr) : PCPP_SMART_PTR(IDnsResourceData)(ptr) {}

        //Visual studio has always been stupid about returning something useful for __cplusplus
        //Only recently was this fixed - and even then it requires a specific hack to the command line during build
        //Its easier/more consistent to test _MSC_VER in VS
        //https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=vs-2017

#if __cplusplus <= 199711L && _MSC_VER < 1800 //Maybe this can be 1600 for VS2010
        DnsResourceDataPtr(const DnsResourceDataPtr& other) : PCPP_SMART_PTR(IDnsResourceData)((DnsResourceDataPtr&)other) {}
#endif

        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() {}

        bool operator==(const StringDnsResourceData& other) const { return m_Data == other.m_Data; }

        // implement abstract methods

        std::string toString() const { return m_Data; }
        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;
    };


    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 { return m_Data.toString(); }
        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;
    };


    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 { return m_Data.toString(); }
        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;
    };


    class MxDnsResourceData : public IDnsResourceData
    {
    public:

        struct MxData
        {
            uint16_t preference;
            std::string mailExchange;
        };

        MxDnsResourceData(uint8_t* dataPtr, size_t dataLen, IDnsResource* dnsResource);

        MxDnsResourceData(const uint16_t& preference, const std::string& mailExchange);

        ~MxDnsResourceData() {}

        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;

        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;

    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() { if (m_Data != NULL) delete [] m_Data; }

        GenericDnsResourceData& operator=(const GenericDnsResourceData& other);

        bool operator==(const GenericDnsResourceData& other) const;

        // implement abstract methods

        std::string toString() const;
        bool toByteArr(uint8_t* arr, size_t& arrLength, IDnsResource* dnsResource) const;
    };

}

#endif // PACKETPP_DNS_RESOURCE_DATA