txt_like.h

Go to the documentation of this file.

// Copyright (C) 2011-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 TXT_LIKE_H
#define TXT_LIKE_H
 
#include <dns/master_lexer.h>
#include <dns/char_string.h>
 
#include <stdint.h>
#include <algorithm>
#include <string>
#include <sstream>
#include <vector>
 
namespace isc {
namespace dns {
namespace rdata {
namespace generic {
namespace detail {
 
template<class Type, uint16_t typeCode>class TXTLikeImpl {
public:
    TXTLikeImpl(util::InputBuffer& buffer, size_t rdata_len) {
        if (rdata_len > MAX_RDLENGTH) {
            isc_throw(InvalidRdataLength, "RDLENGTH too large: " << rdata_len);
        }
 
        if (rdata_len == 0) {    // note that this couldn't happen in the loop.
            isc_throw(DNSMessageFORMERR, "Error in parsing " <<
                      RRType(typeCode) << " RDATA: 0-length character string");
        }
 
        do {
            const uint8_t len = buffer.readUint8();
            if (rdata_len < len + 1) {
                isc_throw(DNSMessageFORMERR, "Error in parsing " <<
                          RRType(typeCode) <<
                          " RDATA: character string length is too large: " <<
                          static_cast<int>(len));
            }
            std::vector<uint8_t> data(len + 1);
            data[0] = len;
            buffer.readData(&data[0] + 1, len);
            string_list_.push_back(data);
 
            rdata_len -= (len + 1);
        } while (rdata_len > 0);
    }
 
    explicit TXTLikeImpl(const std::string& txtstr) {
        std::istringstream ss(txtstr);
        MasterLexer lexer;
        lexer.pushSource(ss);
 
        try {
            buildFromTextHelper(lexer);
            if (lexer.getNextToken().getType() != MasterToken::END_OF_FILE) {
                isc_throw(InvalidRdataText, "Failed to construct " <<
                          RRType(typeCode) << " RDATA from '" << txtstr <<
                          "': extra new line");
            }
        } catch (const MasterLexer::LexerError& ex) {
            isc_throw(InvalidRdataText, "Failed to construct " <<
                      RRType(typeCode) << " RDATA from '" << txtstr << "': "
                      << ex.what());
        }
    }
 
    TXTLikeImpl(MasterLexer& lexer) {
        buildFromTextHelper(lexer);
    }
 
private:
    void buildFromTextHelper(MasterLexer& lexer) {
        while (true) {
            const MasterToken& token = lexer.getNextToken(
                MasterToken::QSTRING, true);
            if (token.getType() != MasterToken::STRING &&
                token.getType() != MasterToken::QSTRING) {
                break;
            }
            string_list_.push_back(std::vector<uint8_t>());
            stringToCharString(token.getStringRegion(), string_list_.back());
        }
 
        // Let upper layer handle eol/eof.
        lexer.ungetToken();
 
        if (string_list_.empty()) {
            isc_throw(InvalidRdataText, "Failed to construct " <<
                      RRType(typeCode) << " RDATA: empty input");
        }
    }
 
public:
    TXTLikeImpl(const TXTLikeImpl& other) :
        string_list_(other.string_list_)
    {}
 
    void
    toWire(util::OutputBuffer& buffer) const {
        for (std::vector<std::vector<uint8_t> >::const_iterator it =
                 string_list_.begin();
             it != string_list_.end();
             ++it)
        {
            buffer.writeData(&(*it)[0], (*it).size());
        }
    }
 
    void
    toWire(AbstractMessageRenderer& renderer) const {
        for (std::vector<std::vector<uint8_t> >::const_iterator it =
                 string_list_.begin();
             it != string_list_.end();
             ++it)
        {
            renderer.writeData(&(*it)[0], (*it).size());
        }
    }
 
    std::string
    toText() const {
        std::string s;
 
        for (std::vector<std::vector<uint8_t> >::const_iterator it =
                 string_list_.begin(); it != string_list_.end(); ++it)
        {
            if (!s.empty()) {
                s.push_back(' ');
            }
            s.push_back('"');
            s.append(charStringToString(*it));
            s.push_back('"');
        }
 
        return (s);
    }
 
    int
    compare(const TXTLikeImpl& other) const {
        // This implementation is not efficient.  Revisit this (TBD).
        util::OutputBuffer this_buffer(0);
        toWire(this_buffer);
        uint8_t const* const this_data = (uint8_t const*)this_buffer.getData();
        const size_t this_len = this_buffer.getLength();
 
        util::OutputBuffer other_buffer(0);
        other.toWire(other_buffer);
        uint8_t const* const other_data
                                      = (uint8_t const*)other_buffer.getData();
        const size_t other_len = other_buffer.getLength();
 
        const size_t cmplen = std::min(this_len, other_len);
        const int cmp = memcmp(this_data, other_data, cmplen);
 
        if (cmp != 0) {
            return (cmp);
        } else {
            return ((this_len == other_len) ? 0 :
                    (this_len < other_len) ? -1 : 1);
        }
    }
 
private:
    std::vector<std::vector<uint8_t> > string_list_;
};
 
}      // namespace detail
}      // namespace generic
}      // namespace rdata
}      // namespace dns
}      // namespace isc
 
#endif //  TXT_LIKE_H