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:
 
        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:
 
        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);
 
        IPv4DnsResourceData(const IPv4Address& addr) : m_Data(addr) {}
 
        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);
 
        IPv6DnsResourceData(const IPv6Address& addr) : m_Data(addr) {}
 
        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(uint8_t* dataPtr, size_t dataLen);
 
        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