message.h

Go to the documentation of this file.

// Copyright (C) 2009-2024 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
 
#include <stdint.h>
 
#include <iterator>
#include <string>
#include <ostream>
 
#include <dns/exceptions.h>
#include <util/buffer.h>
 
#include <dns/edns.h>
#include <dns/question.h>
#include <dns/rrset.h>
 
namespace isc {
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_(0) {
    }
    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 MessageImpl;
typedef boost::shared_ptr<MessageImpl> MessageImplPtr;
 
class Message {
public:
    enum Mode {
        PARSE = 0,              // Parse mode (handling an incoming message)
        RENDER = 1              // Render mode (building an outgoing message)
    };
 
    enum HeaderFlag : int {
        HEADERFLAG_QR = 0x8000, // Query (if cleared) or response (if set)
        HEADERFLAG_AA = 0x0400, // Authoritative answer
        HEADERFLAG_TC = 0x0200, // Truncation
        HEADERFLAG_RD = 0x0100, // Recursion desired
        HEADERFLAG_RA = 0x0080, // Recursion available
        HEADERFLAG_AD = 0x0020, // Authentic %data (RFC4035)
        HEADERFLAG_CD = 0x0010  // DNSSEC checking disabled (RFC4035)
    };
 
    enum Section : int {
        SECTION_QUESTION = 0,   // Question section
        SECTION_ANSWER = 1,     // Answer section
        SECTION_AUTHORITY = 2,  // Authority section
        SECTION_ADDITIONAL = 3  // Additional section
    };
 
 
public:
    Message(Mode mode);
    ~Message() = default;
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 = 0);
 
    enum ParseOptions {
        PARSE_DEFAULT = 0,      // The default options
        PRESERVE_ORDER = 1      // Preserve RR order and don't combine them
    };
 
    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:
    MessageImplPtr 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