rdata.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 RDATA_H
#define RDATA_H
 
#include <dns/master_lexer.h>
#include <dns/master_loader.h>
#include <dns/master_loader_callbacks.h>
#include <dns/exceptions.h>
#include <util/buffer.h>
 
#include <boost/shared_ptr.hpp>
 
#include <memory>
#include <stdint.h>
 
namespace isc {
namespace dns {
class AbstractMessageRenderer;
class RRType;
class RRClass;
class Name;
 
namespace rdata {
 
class InvalidRdataLength : public DNSTextError {
public:
    InvalidRdataLength(const char* file, size_t line, const char* what) :
        DNSTextError(file, line, what) {}
};
 
class InvalidRdataText : public DNSTextError {
public:
    InvalidRdataText(const char* file, size_t line, const char* what) :
        DNSTextError(file, line, what) {}
};
 
class CharStringTooLong : public DNSTextError {
public:
    CharStringTooLong(const char* file, size_t line, const char* what) :
        DNSTextError(file, line, what) {}
};
 
// Forward declaration to define RdataPtr.
class Rdata;
 
typedef boost::shared_ptr<Rdata> RdataPtr;
typedef boost::shared_ptr<const Rdata> ConstRdataPtr;
 
const size_t MAX_RDLENGTH = 65535;
 
const unsigned int MAX_CHARSTRING_LEN = 255;
 
class Rdata {
 
protected:
    Rdata() {}
private:
    Rdata(const Rdata& source);
    void operator=(const Rdata& source);
public:
    virtual ~Rdata() {};
 
 
 
    virtual std::string toText() const = 0;
 
    virtual void toWire(isc::util::OutputBuffer& buff) const = 0;
 
    virtual void toWire(AbstractMessageRenderer& renderer) const = 0;
 
 
 
    virtual int compare(const Rdata& other) const = 0;
 
    virtual uint16_t getLength() const;
};
 
namespace generic {
 
struct GenericImpl;
 
class Generic : public Rdata {
public:
 
 
    explicit Generic(const std::string& rdata_string);
 
    Generic(isc::util::InputBuffer& buff, size_t rdata_len);
 
    Generic(MasterLexer& lexer, const Name* name,
            MasterLoader::Options options, MasterLoaderCallbacks& callbacks);
 
    virtual ~Generic();
    Generic(const Generic& source);
 
    Generic& operator=(const Generic& source);
 
 
 
    virtual std::string toText() const;
 
    virtual void toWire(isc::util::OutputBuffer& buff) const;
 
    virtual void toWire(AbstractMessageRenderer& renderer) const;
 
 
 
    virtual int compare(const Rdata& other) const;
 
private:
    std::unique_ptr<GenericImpl> constructFromLexer(MasterLexer& lexer);
 
    std::unique_ptr<GenericImpl> impl_;
};
 
std::ostream& operator<<(std::ostream& os, const Generic& rdata);
} // end of namespace "generic"
 
//
// Non class-member functions related to Rdata
//
 
 
 
RdataPtr createRdata(const RRType& rrtype, const RRClass& rrclass,
                     const std::string& rdata_string);
 
RdataPtr createRdata(const RRType& rrtype, const RRClass& rrclass,
                     isc::util::InputBuffer& buff, size_t len);
 
RdataPtr createRdata(const RRType& rrtype, const RRClass& rrclass,
                     const Rdata& source);
 
RdataPtr createRdata(const RRType& rrtype, const RRClass& rrclass,
                     MasterLexer& lexer, const Name* origin,
                     MasterLoader::Options options,
                     MasterLoaderCallbacks& callbacks);
 
 
int compareNames(const Name& n1, const Name& n2);
 
} // end of namespace "rdata"
}
}
#endif  // RDATA_H