cfg_option.h

Go to the documentation of this file.

// Copyright (C) 2014-2023 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/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/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/shared_ptr.hpp>
#include <stdint.h>
#include <list>
#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_;
 
    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_) {
        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_;
            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));
    }
};
 
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_
            >
        >
    >
> 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;
 
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_);
    }
 
    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.
        for (OptionContainerTypeIndex::const_iterator od_itr = range.first;
             od_itr != range.second; ++od_itr) {
            list.push_back(*od_itr);
        }
 
        return (list);
    }
 
    size_t del(const std::string& option_space, const uint16_t option_code);
 
    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;
 
    isc::data::ElementPtr
    toElementWithMetadata(const bool include_metadata) const;
 
private:
 
    void encapsulateInternal(const std::string& option_space);
 
    void encapsulateInternal(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