DnsLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_DNS_LAYER
#define PACKETPP_DNS_LAYER
 
#include "DnsLayerEnums.h"
#include "DnsResource.h"
#include "DnsResourceData.h"
#include "Layer.h"
 
 
namespace pcpp
{
 
#pragma pack(push, 1)
    struct dnshdr
    {
        uint16_t transactionID;
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint16_t
            recursionDesired:1,
            truncation:1,
            authoritativeAnswer:1,
            opcode:4,
            queryOrResponse:1,
            responseCode:4,
            checkingDisabled:1,
            authenticData:1,
            zero:1,
            recursionAvailable:1;
#elif (BYTE_ORDER == BIG_ENDIAN)
        uint16_t
            queryOrResponse:1,
            opcode:4,
            authoritativeAnswer:1,
            truncation:1,
            recursionDesired:1,
            recursionAvailable:1,
            zero:1,
            authenticData:1,
            checkingDisabled:1,
            responseCode:4;
#endif
 
        uint16_t numberOfQuestions;
        uint16_t numberOfAnswers;
        uint16_t numberOfAuthority;
        uint16_t numberOfAdditional;
    };
#pragma pack(pop)
 
 
    // forward declarations
    class DnsQuery;
    class IDnsResource;
    class DnsResource;
    class IDnsResourceData;
 
 
    class DnsLayer : public Layer
    {
        friend class IDnsResource;
        friend class DnsQuery;
        friend class DnsResource;
 
    public:
 
        DnsLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DnsLayer();
 
        DnsLayer(const DnsLayer& other);
 
        DnsLayer& operator=(const DnsLayer& other);
 
        virtual ~DnsLayer();
 
        dnshdr* getDnsHeader() const { return (dnshdr*)m_Data; }
 
        DnsQuery* getQuery(const std::string& name, bool exactMatch) const;
 
        DnsQuery* getFirstQuery() const;
 
        DnsQuery* getNextQuery(DnsQuery* query) const;
 
        size_t getQueryCount() const;
 
        DnsQuery* addQuery(const std::string& name, DnsType dnsType, DnsClass dnsClass);
 
        DnsQuery* addQuery(DnsQuery* const copyQuery);
 
        bool removeQuery(const std::string& queryNameToRemove, bool exactMatch);
 
        bool removeQuery(DnsQuery* queryToRemove);
 
        DnsResource* getAnswer(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAnswer() const;
 
        DnsResource* getNextAnswer(DnsResource* answer) const;
 
        size_t getAnswerCount() const;
 
        DnsResource* addAnswer(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl, IDnsResourceData* data);
 
        DnsResource* addAnswer(DnsResource* const copyAnswer);
 
        bool removeAnswer(const std::string& answerNameToRemove, bool exactMatch);
 
        bool removeAnswer(DnsResource* answerToRemove);
 
 
        DnsResource* getAuthority(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAuthority() const;
 
        DnsResource* getNextAuthority(DnsResource* authority) const;
 
        size_t getAuthorityCount() const;
 
        DnsResource* addAuthority(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl, IDnsResourceData* data);
 
        DnsResource* addAuthority(DnsResource* const copyAuthority);
 
        bool removeAuthority(const std::string& authorityNameToRemove, bool exactMatch);
 
        bool removeAuthority(DnsResource* authorityToRemove);
 
 
        DnsResource* getAdditionalRecord(const std::string& name, bool exactMatch) const;
 
        DnsResource* getFirstAdditionalRecord() const;
 
        DnsResource* getNextAdditionalRecord(DnsResource* additionalRecord) const;
 
        size_t getAdditionalRecordCount() const;
 
        DnsResource* addAdditionalRecord(const std::string& name, DnsType dnsType, DnsClass dnsClass, uint32_t ttl, IDnsResourceData* data);
 
        DnsResource* addAdditionalRecord(const std::string& name, DnsType dnsType, uint16_t customData1, uint32_t customData2, IDnsResourceData* data);
 
        DnsResource* addAdditionalRecord(DnsResource* const copyAdditionalRecord);
 
        bool removeAdditionalRecord(const std::string& additionalRecordNameToRemove, bool exactMatch);
 
        bool removeAdditionalRecord(DnsResource* additionalRecordToRemove);
 
        // implement abstract methods
 
        void parseNextLayer() {}
 
        size_t getHeaderLen() const { return m_DataLen; } //No layer above DNS
 
        void computeCalculateFields() {}
 
        std::string toString() const;
 
        OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }
 
        static inline bool isDnsPort(uint16_t port);
 
    private:
        IDnsResource* m_ResourceList;
        DnsQuery*     m_FirstQuery;
        DnsResource*  m_FirstAnswer;
        DnsResource*  m_FirstAuthority;
        DnsResource*  m_FirstAdditional;
 
        IDnsResource* getFirstResource(DnsResourceType resType) const;
        void setFirstResource(DnsResourceType resType, IDnsResource* resource);
 
        using Layer::extendLayer;
        bool extendLayer(int offsetInLayer, size_t numOfBytesToExtend, IDnsResource* resource);
 
        using Layer::shortenLayer;
        bool shortenLayer(int offsetInLayer, size_t numOfBytesToShorten, IDnsResource* resource);
 
        IDnsResource* getResourceByName(IDnsResource* startFrom, size_t resourceCount, const std::string& name, bool exactMatch) const;
 
        void parseResources();
 
        DnsResource* addResource(DnsResourceType resType, const std::string& name, DnsType dnsType, DnsClass dnsClass,
                uint32_t ttl, IDnsResourceData* data);
 
        bool removeResource(IDnsResource* resourceToRemove);
 
    };
 
 
    // implementation of inline methods
 
    bool DnsLayer::isDnsPort(uint16_t port)
    {
        switch (port)
        {
        case 53:
        case 5353:
        case 5355:
            return true;
        default:
            return false;
        }
    }
 
} // namespace pcpp
 
#endif /* PACKETPP_DNS_LAYER */