message.h

Go to the documentation of this file.

// Copyright (C) 2009-2022 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef MESSAGE_H
#define MESSAGE_H 1

#include <stdint.h>

#include <iterator>
#include <string>
#include <ostream>

#include <dns/exceptions.h>

#include <dns/edns.h>
#include <dns/question.h>
#include <dns/rrset.h>

namespace isc {
namespace util {
class InputBuffer;
}

namespace dns {
class TSIGContext;
class TSIGRecord;

class MessageTooShort : public isc::dns::Exception {
public:
    MessageTooShort(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};

class InvalidMessageSection : public isc::dns::Exception {
public:
    InvalidMessageSection(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};

class InvalidMessageOperation : public isc::dns::Exception {
public:
    InvalidMessageOperation(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};

class InvalidMessageUDPSize : public isc::dns::Exception {
public:
    InvalidMessageUDPSize(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};

typedef uint16_t qid_t;

class AbstractMessageRenderer;
class Message;
class MessageImpl;
class Opcode;
class Rcode;

template <typename T>
struct SectionIteratorImpl;

template <typename T>
class SectionIterator {
public:
    // Aliases used to enable iterator behavior on this class
    using iterator_category = std::input_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using reference = T&;

    SectionIterator() : impl_(NULL) {}
    SectionIterator(const SectionIteratorImpl<T>& impl);
    ~SectionIterator();
    SectionIterator(const SectionIterator<T>& source);
    void operator=(const SectionIterator<T>& source);
    SectionIterator<T>& operator++();
    SectionIterator<T> operator++(int);
    const T& operator*() const;
    const T* operator->() const;
    bool operator==(const SectionIterator<T>& other) const;
    bool operator!=(const SectionIterator<T>& other) const;
private:
    SectionIteratorImpl<T>* impl_;
};

typedef SectionIterator<QuestionPtr> QuestionIterator;
typedef SectionIterator<RRsetPtr> RRsetIterator;

class Message {
public:
    enum Mode {
        PARSE = 0,              
        RENDER = 1              
    };

    enum HeaderFlag {
        HEADERFLAG_QR = 0x8000, 
        HEADERFLAG_AA = 0x0400, 
        HEADERFLAG_TC = 0x0200, 
        HEADERFLAG_RD = 0x0100, 
        HEADERFLAG_RA = 0x0080, 
        HEADERFLAG_AD = 0x0020, 
        HEADERFLAG_CD = 0x0010  
    };

    enum Section {
        SECTION_QUESTION = 0,   
        SECTION_ANSWER = 1,     
        SECTION_AUTHORITY = 2,  
        SECTION_ADDITIONAL = 3  
    };


public:
    Message(Mode mode);
    ~Message();
private:
    Message(const Message& source);
    Message& operator=(const Message& source);
public:
    bool getHeaderFlag(const HeaderFlag flag) const;

    void setHeaderFlag(const HeaderFlag flag, const bool on = true);

    qid_t getQid() const;

    void setQid(qid_t qid);

    const Rcode& getRcode() const;

    void setRcode(const Rcode& rcode);

    const Opcode& getOpcode() const;

    void setOpcode(const Opcode& opcode);

    ConstEDNSPtr getEDNS() const;

    void setEDNS(ConstEDNSPtr edns);

    const TSIGRecord* getTSIGRecord() const;

    unsigned int getRRCount(const Section section) const;

    const QuestionIterator beginQuestion() const;

    const QuestionIterator endQuestion() const;

    const RRsetIterator beginSection(const Section section) const;

    const RRsetIterator endSection(const Section section) const;

    void addQuestion(QuestionPtr question);

    void addQuestion(const Question& question);

    void addRRset(const Section section, RRsetPtr rrset);

    bool hasRRset(const Section section, const Name& name,
                  const RRClass& rrclass, const RRType& rrtype) const;

    bool hasRRset(const Section section, const RRsetPtr& rrset) const;

    bool removeRRset(const Section section, RRsetIterator& iterator);

    void clearSection(const Section section);

    // The following methods are not currently implemented.
    //void removeQuestion(QuestionPtr question);
    // notyet:
    //void addRR(const Section section, const RR& rr);
    //void removeRR(const Section section, const RR& rr);

    void clear(Mode mode);

    void appendSection(const Section section, const Message& source);

    void makeResponse();

    std::string toText() const;

    void toWire(AbstractMessageRenderer& renderer,
                TSIGContext* tsig_ctx = NULL);

    enum ParseOptions {
        PARSE_DEFAULT = 0,       
        PRESERVE_ORDER = 1       
    };

    void parseHeader(isc::util::InputBuffer& buffer);

    void fromWire(isc::util::InputBuffer& buffer, ParseOptions options
        = PARSE_DEFAULT);


    static const uint16_t DEFAULT_MAX_UDPSIZE = 512;

    static const uint16_t DEFAULT_MAX_EDNS0_UDPSIZE = 4096;

private:
    MessageImpl* impl_;
};

typedef boost::shared_ptr<Message> MessagePtr;
typedef boost::shared_ptr<const Message> ConstMessagePtr;

std::ostream& operator<<(std::ostream& os, const Message& message);

}  // namespace dns
}  // namespace isc

#endif  // MESSAGE_H