message.h

Go to the documentation of this file.

// Copyright (C) 2009-2017 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 std::iterator<std::input_iterator_tag, T> {
public:
    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);
}
}
#endif  // MESSAGE_H
 
// Local Variables:
// mode: c++
// End: