name.h

Go to the documentation of this file.

// Copyright (C) 2009-2019 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 NAME_H
#define NAME_H 1

#include <stdint.h>

#include <string>
#include <vector>

#include <dns/exceptions.h>

namespace isc {
namespace util {
class InputBuffer;
class OutputBuffer;
}

namespace dns {
class AbstractMessageRenderer;

class EmptyLabel : public NameParserException {
public:
    EmptyLabel(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class TooLongName : public NameParserException {
public:
    TooLongName(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class TooLongLabel : public NameParserException {
public:
    TooLongLabel(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class BadLabelType : public NameParserException {
public:
    BadLabelType(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class BadEscape : public NameParserException {
public:
    BadEscape(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class IncompleteName : public NameParserException {
public:
    IncompleteName(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class MissingNameOrigin : public NameParserException {
public:
    MissingNameOrigin(const char* file, size_t line, const char* what) :
        NameParserException(file, line, what) {}
};

class NameComparisonResult {
public:
    enum NameRelation {
        SUPERDOMAIN = 0,
        SUBDOMAIN = 1,
        EQUAL = 2,
        COMMONANCESTOR = 3,
        NONE = 4
    };


    NameComparisonResult(int order, unsigned int nlabels,
                         NameRelation relation) :
        order_(order), nlabels_(nlabels), relation_(relation) {}


    int getOrder() const { return (order_); }
    unsigned int getCommonLabels() const { return (nlabels_); }
    NameRelation getRelation() const { return (relation_); }
private:
    int order_;
    unsigned int nlabels_;
    NameRelation relation_;
};

class Name {
    // LabelSequences use knowledge about the internal data structure
    // of this class for efficiency (they use the offsets_ vector and
    // the ndata_ string)
    friend class LabelSequence;


private:
    typedef std::basic_string<uint8_t> NameString;
    typedef std::vector<uint8_t> NameOffsets;

    Name() : length_(0), labelcount_(0) {}
public:
    explicit Name(const std::string& namestr, bool downcase = false);

    Name(const char* name_data, size_t data_len, const Name* origin,
         bool downcase = false);

    explicit Name(isc::util::InputBuffer& buffer, bool downcase = false);



    uint8_t at(size_t pos) const
    {
        if (pos >= length_) {
            isc_throw(OutOfRange, "Out of range access in Name::at()");
        }
        return (ndata_[pos]);
    }

    size_t getLength() const { return (length_); }

    unsigned int getLabelCount() const { return (labelcount_); }


    //
    std::string toText(bool omit_final_dot = false) const;

    std::string toRawText(bool omit_final_dot = false) const;

    void toWire(AbstractMessageRenderer& renderer) const;

    void toWire(isc::util::OutputBuffer& buffer) const;


    NameComparisonResult compare(const Name& other) const;

public:
    bool equals(const Name& other) const;

    bool operator==(const Name& other) const { return (equals(other)); }

    bool nequals(const Name& other) const { return (!(equals(other))); }

    bool operator!=(const Name& other) const { return (nequals(other)); }

    bool leq(const Name& other) const;

    bool operator<=(const Name& other) const { return (leq(other)); }

    bool geq(const Name& other) const;

    bool operator>=(const Name& other) const { return (geq(other)); }

    bool lthan(const Name& other) const;

    bool operator<(const Name& other) const { return (lthan(other)); }

    bool gthan(const Name& other) const;

    bool operator>(const Name& other) const { return (gthan(other)); }


    Name split(unsigned int first, unsigned int n) const;

    Name split(unsigned int level) const;

    Name reverse() const;

    Name concatenate(const Name& suffix) const;

    Name& downcase();


    bool isWildcard() const;


    static const size_t MAX_WIRE = 255;

    static const size_t MAX_LABELS = 128;

    static const size_t MAX_LABELLEN = 63;

    static const uint16_t MAX_COMPRESS_POINTER = 0x3fff;
    static const uint16_t COMPRESS_POINTER_MARK8 = 0xc0;
    static const uint16_t COMPRESS_POINTER_MARK16 = 0xc000;


    static const Name& ROOT_NAME();

private:
    NameString ndata_;
    NameOffsets offsets_;
    unsigned int length_;
    unsigned int labelcount_;
};

inline const Name&
Name::ROOT_NAME() {
    static Name root_name(".");
    return (root_name);
}

std::ostream&
operator<<(std::ostream& os, const Name& name);

}
}
#endif // NAME_H

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