name.h

Go to the documentation of this file.

// Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

// $Id$

#ifndef __NAME_H
#define __NAME_H 1

#include <string>
#include <vector>

#include "exceptions.h"

namespace isc {
namespace dns {
class InputBuffer;
class OutputBuffer;
class MessageRenderer;

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

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

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

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

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

class BadPointer : public Exception {
public:
    BadPointer(const char* file, size_t line, const char* what) :
        isc::dns::Exception(file, line, what) {}
};

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

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






    explicit 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 {

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







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

    unsigned int getLabels() const { return (labels_); }















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

    void toWire(MessageRenderer& renderer) const;

    void toWire(OutputBuffer& buffer) const;















    NameComparisonResult compare(const Name& other) const;

    bool equals(const Name& other) const;

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

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

    bool operator!=(const Name& other) const { return (this->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 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;

private:
    std::string ndata_;
    std::vector<unsigned char> offsets_;
    unsigned int length_;
    unsigned int labels_;
};

std::ostream&
operator<<(std::ostream& os, const Name& name);
}
}
#endif // __NAME_H

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

---