rdataclass.h

Go to the documentation of this file.

 
 
#ifndef DNS_RDATACLASS_H
#define DNS_RDATACLASS_H 1
 
#include <dns/master_loader.h>
 
namespace isc {
namespace dns {
class Name;
class MasterLexer;
class MasterLoaderCallbacks;
}
}
// 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 ANY_TSIG_250_H
#define ANY_TSIG_250_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace any {
 
struct TSIGImpl;
 
class TSIG : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    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:
    TSIGImpl* constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    TSIGImpl* impl_;
};
 
} // end of namespace "any"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // ANY_TSIG_250_H
 
// 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 CH_A_1_H
#define CH_A_1_H 1
 
#include <string>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace ch {
 
class A : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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_COMMON_MEMBERS
};
 
} // end of namespace "ch"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // CH_A_1_H
 
// Copyright (C) 2011-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 GENERIC_AFSDB_18_H
#define GENERIC_AFSDB_18_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class AFSDB : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit AFSDB(const std::string& type_str);
    AFSDB(isc::util::InputBuffer& buffer, size_t rdata_len);
    AFSDB(const AFSDB& other);
    AFSDB(
        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_COMMON_MEMBERS
 
    AFSDB& operator=(const AFSDB& source);
 
    const Name& getServer() const;
 
    uint16_t getSubtype() const;
 
private:
    void createFromLexer(MasterLexer& lexer, const Name* origin);
 
    uint16_t subtype_;
    Name server_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_AFSDB_18_H
 
// Copyright (C) 2014-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 GENERIC_CAA_257_H
#define GENERIC_CAA_257_H 1
 
#include <stdint.h>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
#include <string>
#include <vector>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct CAAImpl;
 
class CAA : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit CAA(const std::string& type_str);
    CAA(isc::util::InputBuffer& buffer, size_t rdata_len);
    CAA(const CAA& other);
    CAA(
        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_COMMON_MEMBERS
 
    CAA(uint8_t flags, const std::string& tag, const std::string& value);
    CAA& operator=(const CAA& source);
    ~CAA();
 
 
    uint8_t getFlags() const;
 
    const std::string& getTag() const;
 
    const std::vector<uint8_t>& getValue() const;
 
private:
    CAAImpl* constructFromLexer(MasterLexer& lexer);
 
    CAAImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_CAA_257_H
 
// 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 GENERIC_CNAME_5_H
#define GENERIC_CNAME_5_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class CNAME : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit CNAME(const std::string& type_str);
    CNAME(isc::util::InputBuffer& buffer, size_t rdata_len);
    CNAME(const CNAME& other);
    CNAME(
        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_COMMON_MEMBERS
 
    // CNAME specific methods
    CNAME(const Name& cname);
    const Name& getCname() const;
private:
    Name cname_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_CNAME_5_H
 
// Copyright (C) 2011-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 GENERIC_DLV_32769_H
#define GENERIC_DLV_32769_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
namespace detail {
template <class Type, uint16_t typeCode> class DSLikeImpl;
}
 
class DLV : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit DLV(const std::string& type_str);
    DLV(isc::util::InputBuffer& buffer, size_t rdata_len);
    DLV(const DLV& other);
    DLV(
        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_COMMON_MEMBERS
 
    DLV& operator=(const DLV& source);
 
    ~DLV();
 
    uint16_t getTag() const;
private:
    typedef detail::DSLikeImpl<DLV, 32769> DLVImpl;
    DLVImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_DLV_32769_H
 
// 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 GENERIC_DNAME_39_H
#define GENERIC_DNAME_39_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class DNAME : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit DNAME(const std::string& type_str);
    DNAME(isc::util::InputBuffer& buffer, size_t rdata_len);
    DNAME(const DNAME& other);
    DNAME(
        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_COMMON_MEMBERS
 
    // DNAME specific methods
    DNAME(const Name& dname);
    const Name& getDname() const;
private:
    Name dname_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_DNAME_39_H
 
// 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/.
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
#include <dns/master_lexer.h>
 
#ifndef GENERIC_DNSKEY_48_H
#define GENERIC_DNSKEY_48_H 1
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct DNSKEYImpl;
 
class DNSKEY : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit DNSKEY(const std::string& type_str);
    DNSKEY(isc::util::InputBuffer& buffer, size_t rdata_len);
    DNSKEY(const DNSKEY& other);
    DNSKEY(
        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_COMMON_MEMBERS
    DNSKEY& operator=(const DNSKEY& source);
    ~DNSKEY();
 
 
    uint16_t getTag() const;
 
    uint16_t getFlags() const;
    uint8_t getAlgorithm() const;
 
private:
    DNSKEYImpl* constructFromLexer(isc::dns::MasterLexer& lexer);
 
    DNSKEYImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_DNSKEY_48_H
 
// Copyright (C) 2011-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 GENERIC_DS_43_H
#define GENERIC_DS_43_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
namespace detail {
template <class Type, uint16_t typeCode> class DSLikeImpl;
}
 
class DS : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit DS(const std::string& type_str);
    DS(isc::util::InputBuffer& buffer, size_t rdata_len);
    DS(const DS& other);
    DS(
        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_COMMON_MEMBERS
 
    DS& operator=(const DS& source);
 
    ~DS();
 
    uint16_t getTag() const;
private:
    typedef detail::DSLikeImpl<DS, 43> DSImpl;
    DSImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_DS_43_H
 
// Copyright (C) 2011-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 GENERIC_HINFO_13_H
#define GENERIC_HINFO_13_H 1
#include <stdint.h>
 
#include <string>
 
#include <boost/scoped_ptr.hpp>
#include <boost/noncopyable.hpp>
 
#include <dns/name.h>
#include <dns/rdata.h>
#include <util/buffer.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class HINFOImpl;
 
class HINFO : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit HINFO(const std::string& type_str);
    HINFO(isc::util::InputBuffer& buffer, size_t rdata_len);
    HINFO(const HINFO& other);
    HINFO(
        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_COMMON_MEMBERS
 
    // HINFO specific methods
    ~HINFO();
 
    HINFO& operator=(const HINFO&);
 
    const std::string getCPU() const;
    const std::string getOS() const;
 
private:
    template <typename T>
    void toWireHelper(T& outputer) const;
 
    boost::scoped_ptr<HINFOImpl> impl_;
};
 
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_HINFO_13_H
 
// Copyright (C) 2011-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 GENERIC_MINFO_14_H
#define GENERIC_MINFO_14_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class MINFO : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit MINFO(const std::string& type_str);
    MINFO(isc::util::InputBuffer& buffer, size_t rdata_len);
    MINFO(const MINFO& other);
    MINFO(
        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_COMMON_MEMBERS
 
    MINFO& operator=(const MINFO& source);
 
    Name getRmailbox() const { return (rmailbox_); }
 
    Name getEmailbox() const { return (emailbox_); }
 
private:
    Name rmailbox_;
    Name emailbox_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_MINFO_14_H
 
// 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 GENERIC_MX_15_H
#define GENERIC_MX_15_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class MX : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit MX(const std::string& type_str);
    MX(isc::util::InputBuffer& buffer, size_t rdata_len);
    MX(const MX& other);
    MX(
        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_COMMON_MEMBERS
 
    MX(uint16_t preference, const Name& mxname);
 
    const Name& getMXName() const;
    uint16_t getMXPref() const;
 
private:
    void constructFromLexer(isc::dns::MasterLexer& lexer,
                            const isc::dns::Name* origin);
 
    uint16_t preference_;
    Name mxname_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_MX_15_H
 
// Copyright (C) 2011-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 GENERIC_NAPTR_35_H
#define GENERIC_NAPTR_35_H 1
 
#include <string>
 
#include <boost/scoped_ptr.hpp>
 
#include <dns/name.h>
#include <dns/rdata.h>
#include <util/buffer.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class NAPTRImpl;
 
class NAPTR : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit NAPTR(const std::string& type_str);
    NAPTR(isc::util::InputBuffer& buffer, size_t rdata_len);
    NAPTR(const NAPTR& other);
    NAPTR(
        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_COMMON_MEMBERS
 
    // NAPTR specific methods
    ~NAPTR();
 
    NAPTR& operator=(const NAPTR& source);
 
    uint16_t getOrder() const;
    uint16_t getPreference() const;
    const std::string getFlags() const;
    const std::string getServices() const;
    const std::string getRegexp() const;
    const Name& getReplacement() const;
private:
    template <typename T>
    void toWireHelper(T& outputer) const;
 
    boost::scoped_ptr<NAPTRImpl> impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_NAPTR_35_H
 
// 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 GENERIC_NS_2_H
#define GENERIC_NS_2_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class NS : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
    explicit NS(const Name& nsname) : nsname_(nsname) {}
    const Name& getNSName() const;
private:
    Name nsname_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_NS_2_H
 
// 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/.
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
#include <dns/master_lexer.h>
 
#ifndef GENERIC_NSEC3_50_H
#define GENERIC_NSEC3_50_H 1
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct NSEC3Impl;
 
class NSEC3 : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit NSEC3(const std::string& type_str);
    NSEC3(isc::util::InputBuffer& buffer, size_t rdata_len);
    NSEC3(const NSEC3& other);
    NSEC3(
        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_COMMON_MEMBERS
    NSEC3& operator=(const NSEC3& source);
    ~NSEC3();
 
    uint8_t getHashalg() const;
    uint8_t getFlags() const;
    uint16_t getIterations() const;
    const std::vector<uint8_t>& getSalt() const;
    const std::vector<uint8_t>& getNext() const;
 
private:
    NSEC3Impl* constructFromLexer(isc::dns::MasterLexer& lexer);
 
    NSEC3Impl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_NSEC3_50_H
 
// 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/.
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
#include <dns/master_lexer.h>
 
#ifndef GENERIC_NSEC3PARAM_51_H
#define GENERIC_NSEC3PARAM_51_H 1
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct NSEC3PARAMImpl;
 
class NSEC3PARAM : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit NSEC3PARAM(const std::string& type_str);
    NSEC3PARAM(isc::util::InputBuffer& buffer, size_t rdata_len);
    NSEC3PARAM(const NSEC3PARAM& other);
    NSEC3PARAM(
        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_COMMON_MEMBERS
    NSEC3PARAM& operator=(const NSEC3PARAM& source);
    ~NSEC3PARAM();
 
    uint8_t getHashalg() const;
    uint8_t getFlags() const;
    uint16_t getIterations() const;
    const std::vector<uint8_t>& getSalt() const;
 
private:
    NSEC3PARAMImpl* constructFromLexer(isc::dns::MasterLexer& lexer);
 
    NSEC3PARAMImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_NSEC3PARAM_51_H
 
// 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/.
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rrttl.h>
#include <dns/rdata.h>
 
#ifndef GENERIC_NSEC_47_H
#define GENERIC_NSEC_47_H 1
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct NSECImpl;
 
class NSEC : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit NSEC(const std::string& type_str);
    NSEC(isc::util::InputBuffer& buffer, size_t rdata_len);
    NSEC(const NSEC& other);
    NSEC(
        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_COMMON_MEMBERS
    NSEC& operator=(const NSEC& source);
    ~NSEC();
 
    // specialized methods
 
    const Name& getNextName() const;
 
private:
    NSECImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_NSEC_47_H
 
// 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 GENERIC_OPT_41_H
#define GENERIC_OPT_41_H 1
 
#include <string>
 
#include <dns/rdata.h>
 
#include <boost/shared_ptr.hpp>
 
#include <vector>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct OPTImpl;
 
class OPT : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    // 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:
    OPTImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_OPT_41_H
 
// 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 GENERIC_PTR_12_H
#define GENERIC_PTR_12_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class PTR : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    explicit PTR(const Name& ptr_name) : ptr_name_(ptr_name) {}
    const Name& getPTRName() const;
private:
    Name ptr_name_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_PTR_12_H
 
// Copyright (C) 2011-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 GENERIC_RP_17_H
#define GENERIC_RP_17_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class RP : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit RP(const std::string& type_str);
    RP(isc::util::InputBuffer& buffer, size_t rdata_len);
    RP(const RP& other);
    RP(
        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_COMMON_MEMBERS
 
 
    RP(const Name& mailbox, const Name& text) :
        mailbox_(mailbox), text_(text)
    {}
 
    Name getMailbox() const { return (mailbox_); }
 
    Name getText() const { return (text_); }
 
private:
    Name mailbox_;
    Name text_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_RP_17_H
 
// 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/.
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rrtype.h>
#include <dns/rdata.h>
 
#ifndef GENERIC_RRSIG_46_H
#define GENERIC_RRSIG_46_H 1
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct RRSIGImpl;
 
class RRSIG : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
    RRSIG& operator=(const RRSIG& source);
    ~RRSIG();
 
    // specialized methods
    const RRType& typeCovered() const;
private:
    // helper function for string and lexer constructors
    RRSIGImpl* constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    RRSIGImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_RRSIG_46_H
 
// 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 GENERIC_SOA_6_H
#define GENERIC_SOA_6_H 1
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
#include <dns/serial.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
class SOA : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    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];
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_SOA_6_H
 
// 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 GENERIC_SPF_99_H
#define GENERIC_SPF_99_H 1
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
namespace detail {
template<class Type, uint16_t typeCode> class TXTLikeImpl;
}
 
class SPF : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit SPF(const std::string& type_str);
    SPF(isc::util::InputBuffer& buffer, size_t rdata_len);
    SPF(const SPF& other);
    SPF(
        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_COMMON_MEMBERS
 
    SPF& operator=(const SPF& source);
 
    ~SPF();
 
 
    const std::vector<std::vector<uint8_t> >& getString() const;
 
private:
    typedef isc::dns::rdata::generic::detail::TXTLikeImpl<SPF, 99> SPFImpl;
    SPFImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_SPF_99_H
 
// Copyright (C) 2012-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 GENERIC_SSHFP_44_H
#define GENERIC_SSHFP_44_H 1
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct SSHFPImpl;
 
class SSHFP : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit SSHFP(const std::string& type_str);
    SSHFP(isc::util::InputBuffer& buffer, size_t rdata_len);
    SSHFP(const SSHFP& other);
    SSHFP(
        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_COMMON_MEMBERS
 
    SSHFP(uint8_t algorithm, uint8_t fingerprint_type,
          const std::string& fingerprint);
    SSHFP& operator=(const SSHFP& source);
    ~SSHFP();
 
    uint8_t getAlgorithmNumber() const;
    uint8_t getFingerprintType() const;
    const std::vector<uint8_t>& getFingerprint() const;
    size_t getFingerprintLength() const;
 
private:
    SSHFPImpl* constructFromLexer(MasterLexer& lexer);
 
    SSHFPImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_SSHFP_44_H
 
// Copyright (C) 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 GENERIC_TKEY_249_H
#define GENERIC_TKEY_249_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct TKEYImpl;
 
class TKEY : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    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:
    TKEYImpl* constructFromLexer(MasterLexer& lexer, const Name* origin);
 
    TKEYImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_TKEY_249_H
 
// Copyright (C) 2014-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 GENERIC_TLSA_52_H
#define GENERIC_TLSA_52_H 1
 
#include <stdint.h>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
#include <string>
#include <vector>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
struct TLSAImpl;
 
class TLSA : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit TLSA(const std::string& type_str);
    TLSA(isc::util::InputBuffer& buffer, size_t rdata_len);
    TLSA(const TLSA& other);
    TLSA(
        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_COMMON_MEMBERS
 
    TLSA(uint8_t certificate_usage, uint8_t selector,
         uint8_t matching_type, const std::string& certificate_assoc_data);
    TLSA& operator=(const TLSA& source);
    ~TLSA();
 
    uint8_t getCertificateUsage() const;
    uint8_t getSelector() const;
    uint8_t getMatchingType() const;
    const std::vector<uint8_t>& getData() const;
    size_t getDataLength() const;
 
private:
    TLSAImpl* constructFromLexer(MasterLexer& lexer);
 
    TLSAImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_TLSA_52_H
 
// 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 GENERIC_TXT_16_H
#define GENERIC_TXT_16_H 1
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace generic {
 
namespace detail {
template<class Type, uint16_t typeCode> class TXTLikeImpl;
}
 
class TXT : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    TXT& operator=(const TXT& source);
    ~TXT();
 
private:
    typedef isc::dns::rdata::generic::detail::TXTLikeImpl<TXT, 16> TXTImpl;
    TXTImpl* impl_;
};
 
} // end of namespace "generic"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // GENERIC_TXT_16_H
 
// 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 HS_A_1_H
#define HS_A_1_H 1
 
#include <string>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace hs {
 
class A : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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_COMMON_MEMBERS
};
 
} // end of namespace "hs"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // HS_A_1_H
 
// 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 IN_A_1_H
#define IN_A_1_H 1
 
#include <string>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace in {
 
class A : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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_COMMON_MEMBERS
 
    //We can use the default destructor.
    //virtual ~A() {}
    // notyet:
    //const struct in_addr& getAddress() const { return (addr_); }
private:
    uint32_t addr_;             // raw IPv4 address (network byte order)
};
} // end of namespace "in"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // IN_A_1_H
 
// 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 IN_AAAA_28_H
#define IN_AAAA_28_H 1
 
#include <stdint.h>
 
#include <string>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace in {
 
class AAAA : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
    // notyet:
    //const struct in6_addr& getAddress() const { return (addr_); }
private:
    uint8_t addr_[16];        // raw IPv6 address (network byte order)
};
 
} // end of namespace "in"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // IN_AAAA_28_H
 
// Copyright (C) 2011-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 IN_DHCID_49_H
#define IN_DHCID_49_H 1
 
#include <string>
#include <vector>
 
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace in {
 
class DHCID : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    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;
 
    // END_COMMON_MEMBERS
 
    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 // IN_DHCID_49_H
 
// Copyright (C) 2011-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 IN_SRV_33_H
#define IN_SRV_33_H 1
 
#include <stdint.h>
 
#include <dns/name.h>
#include <dns/rdata.h>
 
namespace isc {
namespace util {
 
class InputBuffer;
class OutputBuffer;
}
 
namespace dns {
 
// BEGIN_COMMON_DECLARATIONS
 
class AbstractMessageRenderer;
 
// END_COMMON_DECLARATIONS
 
namespace rdata {
namespace in {
 
struct SRVImpl;
 
class SRV : public Rdata {
public:
    // BEGIN_COMMON_MEMBERS
 
    explicit SRV(const std::string& type_str);
    SRV(isc::util::InputBuffer& buffer, size_t rdata_len);
    SRV(const SRV& other);
    SRV(
        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_COMMON_MEMBERS
 
    SRV& operator=(const SRV& source);
 
    ~SRV();
 
 
    uint16_t getPriority() const;
 
    uint16_t getWeight() const;
 
    uint16_t getPort() const;
 
    const Name& getTarget() const;
 
private:
    SRVImpl* impl_;
};
 
} // end of namespace "in"
} // end of namespace "rdata"
} // end of namespace "dns"
} // end of namespace "isc"
#endif // IN_SRV_33_H
 
 
#endif // DNS_RDATACLASS_H
 
// Local Variables:
// mode: c++
// End: