option_definition.h

Go to the documentation of this file.

// Copyright (C) 2012-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 OPTION_DEFINITION_H
#define OPTION_DEFINITION_H
 
#include <dhcp/option.h>
#include <dhcp/option_data_types.h>
#include <dhcp/option_space_container.h>
#include <cc/stamped_element.h>
#include <cc/user_context.h>
 
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
#include <string>
 
namespace isc {
namespace dhcp {

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

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

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

class OptionDefinition;

typedef boost::shared_ptr<OptionDefinition> OptionDefinitionPtr;

template<typename T>
class OptionInt;

template<typename T>
class OptionIntArray;

class OptionDefinition : public data::StampedElement {
public:

    typedef std::vector<OptionDataType> RecordFieldsCollection;
    typedef std::vector<OptionDataType>::const_iterator RecordFieldsConstIter;

    explicit OptionDefinition(const std::string& name,
                              const uint16_t code,
                              const std::string& space,
                              const std::string& type,
                              const bool array_type = false);

    explicit OptionDefinition(const std::string& name,
                              const uint16_t code,
                              const std::string& space,
                              const OptionDataType type,
                              const bool array_type = false);

    explicit OptionDefinition(const std::string& name,
                              const uint16_t code,
                              const std::string& space,
                              const std::string& type,
                              const char* encapsulated_space);

    explicit OptionDefinition(const std::string& name,
                              const uint16_t code,
                              const std::string& space,
                              const OptionDataType type,
                              const char* encapsulated_space);

    static OptionDefinitionPtr create(const std::string& name,
                                      const uint16_t code,
                                      const std::string& space,
                                      const std::string& type,
                                      const bool array_type = false);

    static OptionDefinitionPtr create(const std::string& name,
                                      const uint16_t code,
                                      const std::string& space,
                                      const OptionDataType type,
                                      const bool array_type = false);

    static OptionDefinitionPtr create(const std::string& name,
                                      const uint16_t code,
                                      const std::string& space,
                                      const std::string& type,
                                      const char* encapsulated_space);

    static OptionDefinitionPtr create(const std::string& name,
                                      const uint16_t code,
                                      const std::string& space,
                                      const OptionDataType type,
                                      const char* encapsulated_space);



    bool equals(const OptionDefinition& other) const;

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

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


    void addRecordField(const std::string& data_type_name);

    void addRecordField(const OptionDataType data_type);

    bool getArrayType() const { return (array_type_); }

    uint16_t getCode() const { return (code_); }

    std::string getEncapsulatedSpace() const {
        return (encapsulated_space_);
    }

    std::string getName() const { return (name_); }

    const RecordFieldsCollection& getRecordFields() const {
        return (record_fields_);
    }

    std::string getOptionSpaceName() const {
        return (option_space_name_);
    }

    OptionDataType getType() const { return (type_); }

    data::ConstElementPtr getContext() const {
        return (user_context_.getContext());
    }

    void setContext(const data::ConstElementPtr& ctx) {
        user_context_.setContext(ctx);
    }

    void contextToElement(data::ElementPtr map) const {
        user_context_.contextToElement(map);
    }

    void validate() const;

    OptionPtr optionFactory(Option::Universe u,
                            uint16_t type,
                            OptionBufferConstIter begin,
                            OptionBufferConstIter end,
                            bool convenient_notation = false) const;

    OptionPtr optionFactory(Option::Universe u, uint16_t type,
                            const OptionBuffer& buf = OptionBuffer()) const;

    OptionPtr optionFactory(Option::Universe u, uint16_t type,
                            const std::vector<std::string>& values) const;

    static OptionPtr factoryAddrList4(uint16_t type,
                                      OptionBufferConstIter begin,
                                      OptionBufferConstIter end);

    static OptionPtr factoryAddrList6(uint16_t type,
                                      OptionBufferConstIter begin,
                                      OptionBufferConstIter end);

    static OptionPtr factoryEmpty(Option::Universe u, uint16_t type);

    static OptionPtr factoryGeneric(Option::Universe u, uint16_t type,
                                    OptionBufferConstIter begin,
                                    OptionBufferConstIter end);

    static OptionPtr factoryIA6(uint16_t type,
                                OptionBufferConstIter begin,
                                OptionBufferConstIter end);

    static OptionPtr factoryIAAddr6(uint16_t type,
                                    OptionBufferConstIter begin,
                                    OptionBufferConstIter end);

    static OptionPtr factoryIAPrefix6(uint16_t type,
                                      OptionBufferConstIter begin,
                                      OptionBufferConstIter end);

    static OptionPtr factoryOpaqueDataTuples(Option::Universe u,
                                             uint16_t type,
                                             OptionBufferConstIter begin,
                                             OptionBufferConstIter end);

    static OptionPtr factoryOpaqueDataTuples(Option::Universe u,
                                             uint16_t type,
                                             OptionBufferConstIter begin,
                                             OptionBufferConstIter end,
                                             OpaqueDataTuple::LengthFieldType length_field_type);

    template<typename T>
    static OptionPtr factoryInteger(Option::Universe u, uint16_t type,
                                    const std::string& encapsulated_space,
                                    OptionBufferConstIter begin,
                                    OptionBufferConstIter end) {
        OptionPtr option(new OptionInt<T>(u, type, 0));
        option->setEncapsulatedSpace(encapsulated_space);
        option->unpack(begin, end);
        return (option);
    }

    template<typename T>
    static OptionPtr factoryIntegerArray(Option::Universe u,
                                         uint16_t type,
                                         OptionBufferConstIter begin,
                                         OptionBufferConstIter end) {
        OptionPtr option(new OptionIntArray<T>(u, type, begin, end));
        return (option);
    }
 
private:

    bool haveCompressedFqdnListFormat() const;

    OptionPtr factoryFqdnList(Option::Universe u,
                              OptionBufferConstIter begin,
                              OptionBufferConstIter end) const;

    OptionPtr factorySpecialFormatOption(Option::Universe u,
                                         OptionBufferConstIter begin,
                                         OptionBufferConstIter end,
                                         bool convenient_notation = false) const;

    inline bool haveType(const OptionDataType type) const {
        return (type == type_);
    }

    inline bool haveSpace(const std::string& space) const {
        return (space == option_space_name_);
    }

    bool convertToBool(const std::string& value_str) const;

    template<typename T>
    T lexicalCastWithRangeCheck(const std::string& value_str) const;

    void writeToBuffer(Option::Universe u, const std::string& value,
                       const OptionDataType type, OptionBuffer& buf) const;

    std::string name_;
    uint16_t code_;
    OptionDataType type_;
    bool array_type_;
    std::string encapsulated_space_;
    RecordFieldsCollection record_fields_;
    data::UserContext user_context_;
    std::string option_space_name_;
};
 

typedef boost::multi_index_container<
    // Container comprises elements of OptionDefinition type.
    OptionDefinitionPtr,
    // Here we start enumerating various indexes.
    boost::multi_index::indexed_by<
        // Sequenced index allows accessing elements in the same way
        // as elements in std::list. Sequenced is an index #0.
        boost::multi_index::sequenced<>,
        // Start definition of index #1.
        boost::multi_index::hashed_non_unique<
            // Use option type as the index key. The type is held
            // in OptionDefinition object so we have to call
            // OptionDefinition::getCode to retrieve this key
            // for each element. The option code is non-unique so
            // multiple elements with the same option code can
            // be returned by this index.
            boost::multi_index::const_mem_fun<
                OptionDefinition,
                uint16_t,
                &OptionDefinition::getCode
            >
        >,
        // Start definition of index #2
        boost::multi_index::hashed_non_unique<
            // Use option name as the index key. This value is
            // returned by the @c OptionDefinition::getName
            // method.
            boost::multi_index::const_mem_fun<
                OptionDefinition,
                std::string,
                &OptionDefinition::getName
            >
        >,
        // Start definition of index #3
        boost::multi_index::ordered_non_unique<
            // Use option definition modification time as the index key.
            // This value is returned by the BaseStampedElement::getModificationTime
            boost::multi_index::const_mem_fun<
                data::BaseStampedElement,
                boost::posix_time::ptime,
                &data::StampedElement::getModificationTime
            >
        >,
        // Start definition of index #4.
        // Use StampedElement::getId as a key.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::tag<OptionIdIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement, uint64_t,
                                              &data::BaseStampedElement::getId>
        >
    >
> OptionDefContainer;

typedef boost::shared_ptr<OptionDefContainer> OptionDefContainerPtr;

typedef std::map<std::string, OptionDefContainerPtr> OptionDefContainers;

typedef std::map<uint32_t, OptionDefContainerPtr> VendorOptionDefContainers;

typedef OptionDefContainer::nth_index<1>::type OptionDefContainerTypeIndex;
typedef std::pair<OptionDefContainerTypeIndex::const_iterator,
                  OptionDefContainerTypeIndex::const_iterator> OptionDefContainerTypeRange;

typedef OptionDefContainer::nth_index<2>::type OptionDefContainerNameIndex;
typedef std::pair<OptionDefContainerNameIndex::const_iterator,
                  OptionDefContainerNameIndex::const_iterator> OptionDefContainerNameRange;

typedef OptionSpaceContainer<
    OptionDefContainer, OptionDefinitionPtr, std::string
> BaseOptionDefSpaceContainer;

class OptionDefSpaceContainer : public BaseOptionDefSpaceContainer {
public:

    void addItem(const OptionDefinitionPtr& def) {
        BaseOptionDefSpaceContainer::addItem(def, def->getOptionSpaceName());
    }
};
 
} // namespace isc::dhcp
} // namespace isc
 
#endif // OPTION_DEFINITION_H