rrset.h

Go to the documentation of this file.

// Copyright (C) 2010-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 RRSET_H
#define RRSET_H
 
#include <iostream>
#include <string>
 
#include <boost/shared_ptr.hpp>
 
#include <dns/exceptions.h>
 
#include <dns/rdata.h>
#include <dns/rrtype.h>
#include <util/buffer.h>
 
namespace isc {
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 uint32_t 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 uint32_t toWire(AbstractMessageRenderer& renderer) const = 0;
 
    virtual uint32_t 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 uint32_t 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 uint32_t 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 uint32_t toWire(AbstractMessageRenderer& renderer) const;
 
    virtual uint32_t 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 uint32_t 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:
    boost::shared_ptr<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 uint32_t toWire(AbstractMessageRenderer& renderer) const;
 
    virtual uint32_t 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 uint32_t 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