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