cfg_option.h

Go to the documentation of this file.

// Copyright (C) 2014-2026 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 CFG_OPTION_H
#define CFG_OPTION_H
 
#include <dhcp/option.h>
#include <dhcp/classify.h>
#include <dhcp/option_space_container.h>
#include <cc/cfg_to_element.h>
#include <cc/stamped_element.h>
#include <cc/user_context.h>
#include <dhcpsrv/cfg_option_def.h>
#include <dhcpsrv/key_from_key.h>
#include <boost/foreach.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/shared_ptr.hpp>
#include <stdint.h>
#include <list>
#include <set>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {
 
class OptionDescriptor;

typedef boost::shared_ptr<OptionDescriptor> OptionDescriptorPtr;

typedef std::vector<OptionDescriptor> OptionDescriptorList;

class OptionDescriptor : public data::StampedElement, public data::UserContext {
public:
    OptionPtr option_;

    bool persistent_;

    bool cancelled_;

    std::string formatted_value_;

    std::string space_name_;

    ClientClasses client_classes_;

    OptionDescriptor(const OptionPtr& opt, bool persist, bool cancel,
                     const std::string& formatted_value = "",
                     data::ConstElementPtr user_context = data::ConstElementPtr())
        : data::StampedElement(), option_(opt), persistent_(persist),
          cancelled_(cancel), formatted_value_(formatted_value),
          space_name_() {
        setContext(user_context);
    }

    OptionDescriptor(bool persist, bool cancel)
        : data::StampedElement(), option_(OptionPtr()), persistent_(persist),
          cancelled_(cancel), formatted_value_(), space_name_() {}

    OptionDescriptor(const OptionDescriptor& desc)
        : data::StampedElement(desc),
          option_(desc.option_),
          persistent_(desc.persistent_),
          cancelled_(desc.cancelled_),
          formatted_value_(desc.formatted_value_),
          space_name_(desc.space_name_),
          client_classes_(desc.client_classes_) {
        setContext(desc.getContext());
    }

    OptionDescriptor& operator=(const OptionDescriptor& other) {
        if (this != &other) {
            // Not self-assignment.
            data::StampedElement::operator=(other);
            option_ = other.option_;
            persistent_ = other.persistent_;
            cancelled_ = other.cancelled_;
            formatted_value_ = other.formatted_value_;
            space_name_ = other.space_name_;
            client_classes_ = other.client_classes_;
            setContext(other.getContext());
        }
        return (*this);
    }

    static OptionDescriptorPtr create(const OptionPtr& opt,
                                      bool persist,
                                      bool cancel,
                                      const std::string& formatted_value = "",
                                      data::ConstElementPtr user_context =
                                      data::ConstElementPtr());

    static OptionDescriptorPtr create(bool persist, bool cancel);

    static OptionDescriptorPtr create(const OptionDescriptor& desc);

    bool equals(const OptionDescriptor& other) const;

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

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

    void addClientClass(const std::string& class_name);

    bool allowedForClientClasses(const ClientClasses& cclasses) const;

    ClientClassesPtr copyClientClasses() const;
};

typedef boost::multi_index_container<
    // Container comprises elements of OptionDescriptor type.
    OptionDescriptor,
    // 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<
            // KeyFromKeyExtractor is the index key extractor that allows
            // accessing option type being held by the OptionPtr through
            // OptionDescriptor structure.
            KeyFromKeyExtractor<
                // Use option type as the index key. The type is held
                // in OptionPtr object so we have to call Option::getType
                // to retrieve this key for each element.
                boost::multi_index::const_mem_fun<
                    Option,
                    uint16_t,
                    &Option::getType
                >,
                // Indicate that OptionPtr is a member of
                // OptionDescriptor structure.
                boost::multi_index::member<
                    OptionDescriptor,
                    OptionPtr,
                    &OptionDescriptor::option_
                 >
            >
        >,
        // Start definition of index #2.
        // Use 'persistent' struct member as a key.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::member<
                OptionDescriptor,
                bool,
                &OptionDescriptor::persistent_
            >
        >,
        // Start definition of index #3.
        // Use BaseStampedElement::getModificationTime as a key.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::const_mem_fun<
                data::BaseStampedElement,
                boost::posix_time::ptime,
                &data::BaseStampedElement::getModificationTime
            >
        >,
 
        // Start definition of index #4.
        // Use BaseStampedElement::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>
        >,
        // Start definition of index #5.
        // Use 'cancelled' struct member as a key.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::member<
                OptionDescriptor,
                bool,
                &OptionDescriptor::cancelled_
            >
        >,
        // Start definition of index #6.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::composite_key<
                OptionDescriptor,
                KeyFromKeyExtractor<
                    boost::multi_index::const_mem_fun<
                        Option,
                        uint16_t,
                        &Option::getType
                    >,
                    boost::multi_index::member<
                        OptionDescriptor,
                        OptionPtr,
                        &OptionDescriptor::option_
                    >
                >,
                boost::multi_index::member<OptionDescriptor,
                                           ClientClasses,
                                           &OptionDescriptor::client_classes_>
            >
        >
    >
> OptionContainer;

typedef boost::shared_ptr<OptionContainer> OptionContainerPtr;
typedef OptionContainer::nth_index<1>::type OptionContainerTypeIndex;
typedef std::pair<OptionContainerTypeIndex::const_iterator,
                  OptionContainerTypeIndex::const_iterator> OptionContainerTypeRange;
typedef OptionContainer::nth_index<2>::type OptionContainerPersistIndex;
typedef std::pair<OptionContainerPersistIndex::const_iterator,
                  OptionContainerPersistIndex::const_iterator> OptionContainerPersistRange;
typedef OptionContainer::nth_index<5>::type OptionContainerCancelIndex;
typedef std::pair<OptionContainerCancelIndex::const_iterator,
                  OptionContainerCancelIndex::const_iterator> OptionContainerCancelRange;

typedef OptionContainer::nth_index<6>::type OptionContainerTypeClassesIndex;
typedef std::pair<OptionContainerTypeClassesIndex::const_iterator,
                  OptionContainerTypeClassesIndex::const_iterator> OptionContainerTypeClassesRange;

class CfgOption : public isc::data::CfgToElement {
public:

    CfgOption();

    bool empty() const;



    bool equals(const CfgOption& other) const;

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

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


    void add(const OptionPtr& option, const bool persistent,
             const bool cancelled, const std::string& option_space,
             const uint64_t id = 0);

    void add(const OptionDescriptor& desc, const std::string& option_space);

    void replace(const OptionDescriptor& desc, const std::string& option_space);

    void merge(CfgOptionDefPtr cfg_def, CfgOption& other);

    void createOptions(CfgOptionDefPtr cfg_def);

    static bool createDescriptorOption(CfgOptionDefPtr cfg_def, const std::string& space,
                                       OptionDescriptor& opt_desc);

    void mergeTo(CfgOption& other) const;

    void copyTo(CfgOption& other) const;

    void encapsulate();

    bool isEncapsulated() const {
        return (encapsulated_);
    }

    static std::set<std::string> multiple_encapsulating_spaces_;

    OptionContainerPtr getAll(const std::string& option_space) const;

    OptionContainerPtr getAll(const uint32_t vendor_id) const;

    OptionContainerPtr getAllCombined(const std::string& option_space) const;

    template<typename Selector>
    OptionDescriptor get(const Selector& key,
                         const uint16_t option_code) const {
 
        // Check for presence of options.
        OptionContainerPtr options = getAll(key);
        if (!options || options->empty()) {
            return (OptionDescriptor(false, false));
        }
 
        // Some options present, locate the one we are interested in.
        const OptionContainerTypeIndex& idx = options->get<1>();
        OptionContainerTypeIndex::const_iterator od_itr = idx.find(option_code);
        if (od_itr == idx.end()) {
            return (OptionDescriptor(false, false));
        }
 
        return (*od_itr);
    }

    template<typename Selector>
    OptionDescriptorList getList(const Selector& key,
                                 const uint16_t option_code) const {
 
        OptionDescriptorList list;
        // Check for presence of options.
        OptionContainerPtr options = getAll(key);
        if (!options || options->empty()) {
            return (list);
        }
 
        // Some options present, locate the one we are interested in.
        const OptionContainerTypeIndex& idx = options->get<1>();
        OptionContainerTypeRange range = idx.equal_range(option_code);
        // This code copies descriptors and can be optimized not doing this.
        BOOST_FOREACH(auto const& od_itr, range) {
            list.push_back(od_itr);
        }
 
        return (list);
    }

    template<typename Selector>
    OptionDescriptor get(const Selector& key,
                         const uint16_t option_code,
                         const ClientClasses& client_classes) const {
 
        // Check for presence of options.
        OptionContainerPtr options = getAll(key);
        if (!options || options->empty()) {
            return (OptionDescriptor(false, false));
        }
 
        // Some options present, locate the one we are interested in
        // using code + client_classes index.
        auto& idx6 = options->get<6>();
        auto const& od_itr6 = idx6.find(boost::make_tuple(option_code, client_classes));
        if (od_itr6 == idx6.end()) {
            return (OptionDescriptor(false, false));
        }
 
        return (*od_itr6);
    }

    template<typename Selector>
    OptionDescriptor allowedForClientClasses(const Selector& key,
                                             const uint16_t option_code,
                                             const ClientClasses& cclasses) const {
        // Check for presence of options.
        OptionContainerPtr options = getAll(key);
        if (!options || options->empty()) {
            return (OptionDescriptor(false, false));
        }
 
        // We treat the empty client-classes case (if present) as a default.
        // If we encounter it before we reach the end of the list of options
        // remember it but keep checking the list for an actual match. We do
        // it this way to avoid expecting the entries in any particular order.
        auto & index = options->get<1>();
        auto range = index.equal_range(option_code);
        switch (std::distance(range.first, range.second)) {
        case 0:
            break;
        case 1:
            if ((*range.first).allowedForClientClasses(cclasses)) {
                return (*range.first);
            }
            break;
        default:
        {
            auto default_opt = index.end();
            auto otr = range.first;
            while (otr != range.second) {
                if ((*otr).allowedForClientClasses(cclasses)) {
                    if (!(*otr).client_classes_.empty()) {
                        return (*otr);
                    }
 
                    default_opt = otr;
                }
 
                ++otr;
            }
 
            // If we have a default return it.
            if (default_opt != index.end()) {
                return (*default_opt);
            }
        }}
 
        // None allowed.
        return (OptionDescriptor(false, false));
    }

    size_t del(const std::string& option_space, const uint16_t option_code);

    size_t del(const std::string& option_space, const uint16_t option_code,
               const ClientClasses& client_classes);

    size_t del(const uint32_t vendor_id, const uint16_t option_code);

    size_t del(const uint64_t id);

    std::list<std::string> getOptionSpaceNames() const {
        return (options_.getOptionSpaceNames());
    }

    std::list<uint32_t> getVendorIds() const {
        return (vendor_options_.getOptionSpaceNames());
    }

    std::list<std::string> getVendorIdsSpaceNames() const;

    virtual isc::data::ElementPtr toElement() const;

    virtual isc::data::ElementPtr toElement(CfgOptionDefPtr cfg_option_def) const;

    isc::data::ElementPtr
    toElementWithMetadata(const bool include_metadata,
                          CfgOptionDefPtr cfg_option_def = CfgOptionDefPtr()) const;
 
private:

    void encapsulateInternal(const std::string& option_space);

    void encapsulateInternal(const OptionPtr& option);

    void decapsulateInternal(const OptionPtr& option);

    template <typename Selector>
    void mergeInternal(const OptionSpaceContainer<OptionContainer,
                       OptionDescriptor, Selector>& src_container,
                       OptionSpaceContainer<OptionContainer,
                       OptionDescriptor, Selector>& dest_container) const;

    bool encapsulated_;

    typedef OptionSpaceContainer<OptionContainer, OptionDescriptor,
                                 std::string> OptionSpaceCollection;
    OptionSpaceCollection options_;

    typedef OptionSpaceContainer<OptionContainer, OptionDescriptor,
                                 uint32_t> VendorOptionSpaceCollection;
    VendorOptionSpaceCollection vendor_options_;
};



typedef boost::shared_ptr<CfgOption> CfgOptionPtr;

typedef boost::shared_ptr<const CfgOption> ConstCfgOptionPtr;

typedef std::list<ConstCfgOptionPtr> CfgOptionList;

 
}
}
 
#endif // CFG_OPTION_H