rrset.h

Go to the documentation of this file.

// Copyright (C) 2010-2021 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 RRSET_H
#define RRSET_H 1

#include <iostream>
#include <string>

#include <boost/shared_ptr.hpp>

#include <dns/exceptions.h>

#include <dns/rdata.h>
#include <dns/rrtype.h>

namespace isc {
namespace util {
class OututBuffer;
}

namespace dns {

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

// forward declarations
class Name;
class RRType;
class RRClass;
class RRTTL;
class AbstractMessageRenderer;
class AbstractRRset;
class BasicRRset;
class RdataIterator;
class BasicRRsetImpl;
class RRset;

typedef boost::shared_ptr<AbstractRRset> RRsetPtr;

typedef boost::shared_ptr<const AbstractRRset> ConstRRsetPtr;

typedef boost::shared_ptr<RdataIterator> RdataIteratorPtr;


class AbstractRRset {

private:
    AbstractRRset(const AbstractRRset& source);
    AbstractRRset& operator=(const AbstractRRset& source);
protected:
    AbstractRRset() {}
public:
    virtual ~AbstractRRset() {}


    virtual unsigned int getRdataCount() const = 0;

    virtual uint16_t getLength() const = 0;

    virtual const Name& getName() const = 0;

    virtual const RRClass& getClass() const = 0;

    virtual const RRType& getType() const = 0;

    virtual const RRTTL& getTTL() const = 0;

    virtual void setTTL(const RRTTL& ttl) = 0;


    virtual std::string toText() const = 0;

    virtual unsigned int toWire(AbstractMessageRenderer& renderer) const = 0;

    virtual unsigned int toWire(isc::util::OutputBuffer& buffer) const = 0;


    virtual void addRdata(rdata::ConstRdataPtr rdata) = 0;

    virtual void addRdata(const rdata::Rdata& rdata) = 0;

    virtual void addRdata(const std::string& rdata_str) = 0;

    virtual RdataIteratorPtr getRdataIterator() const = 0;


    virtual RRsetPtr getRRsig() const = 0;

    virtual unsigned int getRRsigDataCount() const = 0;

    virtual void addRRsig(const rdata::ConstRdataPtr& rdata) = 0;

    virtual void addRRsig(const rdata::RdataPtr& rdata) = 0;

    virtual void addRRsig(const AbstractRRset& sigs) = 0;

    virtual void addRRsig(const ConstRRsetPtr& sigs) = 0;

    virtual void addRRsig(const RRsetPtr& sigs) = 0;

    virtual void removeRRsig() = 0;

    virtual bool isSameKind(const AbstractRRset& other) const;

};

class RdataIterator {

protected:
    RdataIterator() {}
public:
    virtual ~RdataIterator() {}
private:
    RdataIterator(const RdataIterator& source);
    RdataIterator& operator=(const RdataIterator& source);

public:
    virtual void first() = 0;

    virtual void next() = 0;

    virtual const rdata::Rdata& getCurrent() const = 0;

    virtual bool isLast() const = 0;
};

class BasicRRset : public AbstractRRset {

private:
    BasicRRset(const BasicRRset& source);
    BasicRRset& operator=(const BasicRRset& source);
public:
    BasicRRset(const Name& name, const RRClass& rrclass,
               const RRType& rrtype, const RRTTL& ttl);
    virtual ~BasicRRset();


    virtual unsigned int getRdataCount() const;

    virtual uint16_t getLength() const;

    virtual const Name& getName() const;

    virtual const RRClass& getClass() const;

    virtual const RRType& getType() const;

    virtual const RRTTL& getTTL() const;

    virtual void setTTL(const RRTTL& ttl);


    virtual std::string toText() const;

    virtual unsigned int toWire(AbstractMessageRenderer& renderer) const;

    virtual unsigned int toWire(isc::util::OutputBuffer& buffer) const;


    virtual void addRdata(rdata::ConstRdataPtr rdata);

    virtual void addRdata(const rdata::Rdata& rdata);

    virtual void addRdata(const std::string& rdata_str);

    virtual RdataIteratorPtr getRdataIterator() const;


    virtual RRsetPtr getRRsig() const {
        return (RRsetPtr());
    }

    virtual unsigned int getRRsigDataCount() const {
        return (0);
    }

    virtual void addRRsig(const rdata::ConstRdataPtr&) {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the addRRsig() method");
    }

    virtual void addRRsig(const rdata::RdataPtr&) {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the addRRsig() method");
    }

    virtual void addRRsig(const AbstractRRset&) {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the addRRsig() method");
    }

    virtual void addRRsig(const ConstRRsetPtr&) {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the addRRsig() method");
    }

    virtual void addRRsig(const RRsetPtr&) {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the addRRsig() method");
    }

    virtual void removeRRsig() {
        isc_throw(NotImplemented,
                  "BasicRRset does not implement the removeRRsig() method");
    }
private:
    BasicRRsetImpl* impl_;
};

class RRset : public BasicRRset {
public:
    RRset(const Name& name, const RRClass& rrclass,
          const RRType& rrtype, const RRTTL& ttl);

    virtual ~RRset();

    virtual uint16_t getLength() const;

    virtual unsigned int toWire(AbstractMessageRenderer& renderer) const;

    virtual unsigned int toWire(isc::util::OutputBuffer& buffer) const;

    virtual void setTTL(const RRTTL& ttl) {
        BasicRRset::setTTL(ttl);
        if (rrsig_) {
            rrsig_->setTTL(ttl);
        }
    }

    virtual void addRRsig(const rdata::ConstRdataPtr& rdata) {
        if (!rrsig_) {
            rrsig_ = RRsetPtr(new RRset(getName(), getClass(),
                                        RRType::RRSIG(), getTTL()));
        }
        rrsig_->addRdata(rdata);
    }

    // Workaround for older versions of boost: some don't support implicit
    // conversion from shared_ptr<X> to shared_ptr<const X>.  Note: we should
    // revisit the interface of managing RRset signatures, at which point this
    // problem may go away.
    virtual void addRRsig(const rdata::RdataPtr& rdata) {
        // Don't try to convert as a reference here.  SunStudio will reject it.
        addRRsig(static_cast<const rdata::ConstRdataPtr>(rdata));
    }

    virtual void addRRsig(const AbstractRRset& sigs) {
        RdataIteratorPtr it = sigs.getRdataIterator();

        if (!rrsig_) {
            rrsig_ = RRsetPtr(new RRset(getName(), getClass(),
                                        RRType::RRSIG(), getTTL()));
        }

        for (it->first(); !it->isLast(); it->next()) {
            rrsig_->addRdata(it->getCurrent());
        }
    }

    virtual void addRRsig(const ConstRRsetPtr& sigs) { addRRsig(*sigs); }

    // Another workaround for older boost (see above)
    virtual void addRRsig(const RRsetPtr& sigs) { addRRsig(*sigs); }

    virtual void removeRRsig() { rrsig_ = RRsetPtr(); }

    virtual RRsetPtr getRRsig() const { return (rrsig_); }

    virtual unsigned int getRRsigDataCount() const;

private:
    RRsetPtr rrsig_;
};


std::ostream& operator<<(std::ostream& os, const AbstractRRset& rrset);
} // end of namespace dns
} // end of namespace isc
#endif  // RRSET_H

// Local Variables: 
// mode: c++
// End: