option_custom.h

Go to the documentation of this file.

// Copyright (C) 2012-2022 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 OPTION_CUSTOM_H
#define OPTION_CUSTOM_H

#include <asiolink/io_address.h>
#include <dhcp/option.h>
#include <dhcp/option_definition.h>
#include <exceptions/isc_assert.h>
#include <util/io_utilities.h>

namespace isc {
namespace dhcp {

class OptionCustom : public Option {
public:

    OptionCustom(const OptionDefinition& def, Universe u);

    OptionCustom(const OptionDefinition& def, Universe u, const OptionBuffer& data);

    OptionCustom(const OptionDefinition& def, Universe u,
                 OptionBufferConstIter first, OptionBufferConstIter last);

    virtual OptionPtr clone() const;

    void addArrayDataField(const asiolink::IOAddress& address);

    void addArrayDataField(const bool value);

    template<typename T>
    void addArrayDataField(const T value) {
        checkArrayType();
        OptionDataType data_type = definition_.getType();
        // Handle record last field.
        if (data_type == OPT_RECORD_TYPE) {
            data_type = definition_.getRecordFields().back();
        }
        if (OptionDataTypeTraits<T>::type != data_type) {
            isc_throw(isc::dhcp::InvalidDataType,
                      "specified data type " << data_type << " does not"
                      " match the data type in an option definition");
        }

        OptionBuffer buf;
        OptionDataTypeUtil::writeInt<T>(value, buf);
        buffers_.push_back(buf);
    }

    void addArrayDataField(const std::string& value);

    void addArrayDataField(const OpaqueDataTuple& value);

    void addArrayDataField(const PrefixLen& prefix_len,
                           const asiolink::IOAddress& prefix);

    void addArrayDataField(const PSIDLen& psid_len, const PSID& psid);

    uint32_t getDataFieldsNum() const { return (buffers_.size()); }

    asiolink::IOAddress readAddress(const uint32_t index = 0) const;

    void writeAddress(const asiolink::IOAddress& address,
                      const uint32_t index = 0);

    const OptionBuffer& readBinary(const uint32_t index = 0) const;

    void writeBinary(const OptionBuffer& buf, const uint32_t index = 0);

    std::string readTuple(const uint32_t index = 0) const;

    void readTuple(OpaqueDataTuple& tuple, const uint32_t index = 0) const;

    void writeTuple(const std::string& value, const uint32_t index = 0);

    void writeTuple(const OpaqueDataTuple& value, const uint32_t index = 0);

    bool readBoolean(const uint32_t index = 0) const;

    void writeBoolean(const bool value, const uint32_t index = 0);

    std::string readFqdn(const uint32_t index = 0) const;

    void writeFqdn(const std::string& fqdn, const uint32_t index = 0);

    template<typename T>
    T readInteger(const uint32_t index = 0) const {
        // Check that the index is not out of range.
        checkIndex(index);
        // Check that T points to a valid integer type and this type
        // is consistent with an option definition.
        checkDataType<T>(index);
        // When we created the buffer we have checked that it has a
        // valid size so this condition here should be always fulfilled.
        isc_throw_assert(buffers_[index].size() == OptionDataTypeTraits<T>::len);
        // Read an integer value.
        return (OptionDataTypeUtil::readInt<T>(buffers_[index]));
    }

    template<typename T>
    void writeInteger(const T value, const uint32_t index = 0) {
        // Check that the index is not out of range.
        checkIndex(index);
        // Check that T points to a valid integer type and this type
        // is consistent with an option definition.
        checkDataType<T>(index);
        // Get some temporary buffer.
        OptionBuffer buf;
        // Try to write to the buffer.
        OptionDataTypeUtil::writeInt<T>(value, buf);
        // If successful, replace the old buffer with new one.
        std::swap(buffers_[index], buf);
    }

    PrefixTuple readPrefix(const uint32_t index = 0) const;

    void writePrefix(const PrefixLen& prefix_len,
                     const asiolink::IOAddress& prefix,
                     const uint32_t index = 0);

    PSIDTuple readPsid(const uint32_t index = 0) const;

    void writePsid(const PSIDLen& psid_len, const PSID& psid,
                   const uint32_t index = 0);

    std::string readString(const uint32_t index = 0) const;

    void writeString(const std::string& text,
                     const uint32_t index = 0);

    virtual void pack(isc::util::OutputBuffer& buf, bool check = true) const;

    virtual void unpack(OptionBufferConstIter begin,
                        OptionBufferConstIter end);

    virtual std::string toText(int indent = 0) const;

    virtual uint16_t len() const;

    void initialize(const OptionBufferConstIter first,
                    const OptionBufferConstIter last);

private:

    inline void checkArrayType() const {
        if (!definition_.getArrayType()) {
            isc_throw(InvalidOperation, "failed to add new array entry to an"
                      << " option. The option is not an array.");
        }
    }

    template<typename T>
    // cppcheck-suppress unusedPrivateFunction
    void checkDataType(const uint32_t index) const;

    void checkIndex(const uint32_t index) const;

    void createBuffer(OptionBuffer& buffer,
                      const OptionDataType data_type) const;

    void createBuffers();

    size_t bufferLength(const OptionDataType data_type, bool in_array,
                        OptionBuffer::const_iterator begin,
                        OptionBuffer::const_iterator end) const;

    void createBuffers(const OptionBuffer& data_buf);

    std::string dataFieldToText(const OptionDataType data_type,
                                const uint32_t index) const;

    using Option::setData;

    OptionDefinition definition_;

    std::vector<OptionBuffer> buffers_;
};

typedef boost::shared_ptr<OptionCustom> OptionCustomPtr;

template<typename T>
void
OptionCustom::checkDataType(const uint32_t index) const {
    // Check that the requested return type is a supported integer.
    if (!OptionDataTypeTraits<T>::integer_type) {
        isc_throw(isc::dhcp::InvalidDataType, "specified data type"
                  " is not a supported integer type.");
    }

    // Get the option definition type.
    OptionDataType data_type = definition_.getType();
    if (data_type == OPT_RECORD_TYPE) {
        const OptionDefinition::RecordFieldsCollection& record_fields =
            definition_.getRecordFields();
        if (definition_.getArrayType()) {
            // If the array flag is set the last record field is an array.
            if (index < record_fields.size()) {
                // Get the data type to be returned.
                data_type = record_fields[index];
            } else {
                // Get the data type to be returned from the last record field.
                data_type = record_fields.back();
            }
        } else {
            // When we initialized buffers we have already checked that
            // the number of these buffers is equal to number of option
            // fields in the record so the condition below should be met.
            isc_throw_assert(index < record_fields.size());
            // Get the data type to be returned.
            data_type = record_fields[index];
        }
    }

    if (OptionDataTypeTraits<T>::type != data_type) {
        isc_throw(isc::dhcp::InvalidDataType,
                  "specified data type " << data_type << " does not"
                  " match the data type in an option definition for field"
                  " index " << index);
    }
}
} // namespace isc::dhcp
} // namespace isc

#endif // OPTION_CUSTOM_H