labelsequence.h

Go to the documentation of this file.

// Copyright (C) 2012-2020 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 LABELSEQUENCE_H
#define LABELSEQUENCE_H 1

#include <dns/name.h>
#include <util/buffer.h>

namespace isc {
namespace dns {

class LabelSequence {
    // Name calls the private toText(bool) method of LabelSequence.
    friend std::string Name::toText(bool) const;

public:
    static const size_t MAX_SERIALIZED_LENGTH =
        Name::MAX_WIRE + Name::MAX_LABELS + 1;


    static const LabelSequence& WILDCARD();

    explicit LabelSequence(const Name& name):
        data_(&name.ndata_[0]),
        offsets_(&name.offsets_[0]),
        first_label_(0),
        last_label_(name.getLabelCount() - 1)
    {}

    explicit LabelSequence(const void* buf);

    LabelSequence(const LabelSequence& src, uint8_t buf[MAX_SERIALIZED_LENGTH]);

    LabelSequence(const LabelSequence& ls):
        data_(ls.data_),
        offsets_(ls.offsets_),
        first_label_(ls.first_label_),
        last_label_(ls.last_label_)
    {}

    LabelSequence& operator=(const LabelSequence& other) {
        if (this != &other) {
            // Not self-assignment.
            data_ = other.data_;
            offsets_ = other.offsets_;
            first_label_ = other.first_label_;
            last_label_ = other.last_label_;
        }
        return (*this);
    }

    const uint8_t* getData(size_t* len) const;

    size_t getDataLength() const;

    size_t getSerializedLength() const;

    void serialize(void* buf, size_t buf_len) const;

    bool equals(const LabelSequence& other, bool case_sensitive = false) const;

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

    NameComparisonResult compare(const LabelSequence& other,
                                 bool case_sensitive = false) const;

    void stripLeft(size_t i);

    void stripRight(size_t i);

    size_t getLabelCount() const {
        return (last_label_ - first_label_ + 1);
    }

    std::string toText() const;

    std::string toRawText(bool omit_final_dot) const;

    void extend(const LabelSequence& labels,
                uint8_t buf[MAX_SERIALIZED_LENGTH]);

private:
    std::string toText(bool omit_final_dot) const;
public:
    size_t getHash(bool case_sensitive) const;

    bool isAbsolute() const;

private:
    const uint8_t* data_;       // wire-format name data
    const uint8_t* offsets_;    // an array of offsets in data_ for the labels
    size_t first_label_;        // index of offsets_ for the first label
    size_t last_label_;         // index of offsets_ for the last label.
                                // can be equal to first_label_, but must not
                                // be smaller (the class ensures that)
};


std::ostream&
operator<<(std::ostream& os, const LabelSequence& label_sequence);

inline const LabelSequence&
LabelSequence::WILDCARD() {
    static const uint8_t wildcard_buf[4] = { 0x01, 0x00, 0x01, '*' };
    static const LabelSequence wild_ls(wildcard_buf);
    return (wild_ls);
}

} // end namespace dns
} // end namespace isc

#endif

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