rdataclass.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 DNS_RDATACLASS_H
#define DNS_RDATACLASS_H
 
#include <dns/master_loader.h>
#include <dns/name.h>
#include <dns/rdata.h>
#include <dns/rrttl.h>
#include <dns/rrtype.h>
#include <dns/serial.h>
#include <util/buffer.h>
 
#include <boost/shared_ptr.hpp>
 
#include <memory>
#include <stdint.h>
#include <string>
#include <vector>
 
namespace isc {
namespace dns {
 
class Name;
class MasterLexer;
class MasterLoaderCallbacks;
class AbstractMessageRenderer;
 
namespace rdata {
namespace any {
 
struct TSIGImpl;
 
class TSIG : public Rdata {
public:
    explicit TSIG(const std::string& type_str);
    TSIG(isc::util::InputBuffer& buffer, size_t rdata_len);
    TSIG(const TSIG& other);
    TSIG(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    TSIG(const Name& algorithm, uint64_t time_signed, uint16_t fudge,
         uint16_t mac_size, const void* mac, uint16_t original_id,
         uint16_t error, uint16_t other_len, const void* other_data);
 
    TSIG& operator=(const TSIG& source);
 
    ~TSIG();
 
    const Name& getAlgorithm() const;
 
    uint64_t getTimeSigned() const;
 
    uint16_t getFudge() const;
 
    uint16_t getMACSize() const;
 
    const void* getMAC() const;
 
    uint16_t getOriginalID() const;
 
    uint16_t getError() const;
 
    uint16_t getOtherLen() const;
 
    const void* getOtherData() const;
private:
    std::unique_ptr<TSIGImpl> constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    std::unique_ptr<TSIGImpl> impl_;
};
 
} // end of namespace "any"
 
namespace ch {
 
class A : public Rdata {
public:
    explicit A(const std::string& type_str);
    A(isc::util::InputBuffer& buffer, size_t rdata_len);
    A(const A& other);
    A(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
};
 
} // end of namespace "ch"
 
namespace generic {
namespace detail {
 
inline Name
createNameFromLexer(MasterLexer& lexer, const Name* origin) {
    const MasterToken::StringRegion& str_region =
        lexer.getNextToken(MasterToken::STRING).getStringRegion();
    return (Name(str_region.beg, str_region.len, origin));
}
 
template<class Type, uint16_t typeCode>
class TXTLikeImpl;
 
} // namespace detail
 
class NS : public Rdata {
public:
    explicit NS(const std::string& type_str);
    NS(isc::util::InputBuffer& buffer, size_t rdata_len);
    NS(const NS& other);
    NS(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    explicit NS(const Name& nsname) : nsname_(nsname) {
    }
    const Name& getNSName() const;
private:
    Name nsname_;
};
 
struct OPTImpl;
 
class OPT : public Rdata {
public:
    explicit OPT(const std::string& type_str);
    OPT(isc::util::InputBuffer& buffer, size_t rdata_len);
    OPT(const OPT& other);
    OPT(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    // The default constructor makes sense for OPT as it can be empty.
    OPT();
    OPT& operator=(const OPT& source);
    ~OPT();
 
    class PseudoRR {
    public:
        PseudoRR(uint16_t code,
                 boost::shared_ptr<std::vector<uint8_t> >& data);
 
        uint16_t getCode() const;
 
        const uint8_t* getData() const;
 
        uint16_t getLength() const;
 
    private:
        uint16_t code_;
        boost::shared_ptr<std::vector<uint8_t>> data_;
    };
 
    void appendPseudoRR(uint16_t code, const uint8_t* data, uint16_t length);
 
    const std::vector<PseudoRR>& getPseudoRRs() const;
 
private:
    std::unique_ptr<OPTImpl> impl_;
};
 
class PTR : public Rdata {
public:
    explicit PTR(const std::string& type_str);
    PTR(isc::util::InputBuffer& buffer, size_t rdata_len);
    PTR(const PTR& other);
    PTR(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    explicit PTR(const Name& ptr_name) : ptr_name_(ptr_name) {
    }
    const Name& getPTRName() const;
private:
    Name ptr_name_;
};
 
struct RRSIGImpl;
 
class RRSIG : public Rdata {
public:
    explicit RRSIG(const std::string& type_str);
    RRSIG(isc::util::InputBuffer& buffer, size_t rdata_len);
    RRSIG(const RRSIG& other);
    RRSIG(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    RRSIG& operator=(const RRSIG& source);
    ~RRSIG();
 
    // specialized methods
    const RRType& typeCovered() const;
private:
    // helper function for string and lexer constructors
    std::unique_ptr<RRSIGImpl> constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    std::unique_ptr<RRSIGImpl> impl_;
};
 
class SOA : public Rdata {
public:
    explicit SOA(const std::string& type_str);
    SOA(isc::util::InputBuffer& buffer, size_t rdata_len);
    SOA(const SOA& other);
    SOA(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    SOA(const Name& mname, const Name& rname, uint32_t serial,
        uint32_t refresh, uint32_t retry, uint32_t expire,
        uint32_t minimum);
 
    Serial getSerial() const;
 
    uint32_t getMinimum() const;
private:
    Name mname_;
    Name rname_;
    uint8_t numdata_[20];
};
 
struct TKEYImpl;
 
class TKEY : public Rdata {
public:
    explicit TKEY(const std::string& type_str);
    TKEY(isc::util::InputBuffer& buffer, size_t rdata_len);
    TKEY(const TKEY& other);
    TKEY(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    TKEY(const Name& algorithm, uint32_t inception, uint32_t expire,
         uint16_t mode, uint16_t error, uint16_t key_len,
         const void* key, uint16_t other_len, const void* other_data);
 
    TKEY& operator=(const TKEY& source);
 
    ~TKEY();
 
    const Name& getAlgorithm() const;
 
    uint32_t getInception() const;
 
    std::string getInceptionDate() const;
 
    uint32_t getExpire() const;
 
    std::string getExpireDate() const;
 
    uint16_t getMode() const;
 
    uint16_t getError() const;
 
    uint16_t getKeyLen() const;
 
    const void* getKey() const;
 
    uint16_t getOtherLen() const;
 
    const void* getOtherData() const;
 
    static const uint16_t GSS_API_MODE;
 
private:
    std::unique_ptr<TKEYImpl> constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    std::unique_ptr<TKEYImpl> impl_;
};
 
class TXT : public Rdata {
public:
    explicit TXT(const std::string& type_str);
    TXT(isc::util::InputBuffer& buffer, size_t rdata_len);
    TXT(const TXT& other);
    TXT(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    TXT& operator=(const TXT& source);
    ~TXT();
 
private:
    typedef isc::dns::rdata::generic::detail::TXTLikeImpl<TXT, 16> TXTImpl;
    std::unique_ptr<TXTImpl> impl_;
};
} // namespace generic
 
 
namespace in {
 
class A : public Rdata {
public:
    explicit A(const std::string& type_str);
    A(isc::util::InputBuffer& buffer, size_t rdata_len);
    A(const A& other);
    A(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
private:
    uint32_t addr_;             // raw IPv4 address (network byte order)
};
 
class AAAA : public Rdata {
public:
    explicit AAAA(const std::string& type_str);
    AAAA(isc::util::InputBuffer& buffer, size_t rdata_len);
    AAAA(const AAAA& other);
    AAAA(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
private:
    uint8_t addr_[16];        // raw IPv6 address (network byte order)
};
 
class DHCID : public Rdata {
public:
    explicit DHCID(const std::string& type_str);
    DHCID(isc::util::InputBuffer& buffer, size_t rdata_len);
    DHCID(const DHCID& other);
    DHCID(
        MasterLexer& lexer, const Name* name,
        MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
    virtual std::string toText() const;
    virtual void toWire(isc::util::OutputBuffer& buffer) const;
    virtual void toWire(AbstractMessageRenderer& renderer) const;
    virtual int compare(const Rdata& other) const;
 
    const std::vector<uint8_t>& getDigest() const;
 
private:
    // helper for string and lexer constructors
    void constructFromLexer(MasterLexer& lexer);
 
    std::vector<uint8_t> digest_;
};
 
} // end of namespace "in"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // DNS_RDATACLASS_H