cfg_option.h

Go to the documentation of this file.

// Copyright (C) 2014-2021 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 <string>
#include <list>

namespace isc {
namespace dhcp {

class OptionDescriptor;

typedef boost::shared_ptr<OptionDescriptor> OptionDescriptorPtr;

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

    bool persistent_;

    std::string formatted_value_;

    std::string space_name_;

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

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

    OptionDescriptor(const OptionDescriptor& desc)
        : data::StampedElement(desc),
          option_(desc.option_),
          persistent_(desc.persistent_),
          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_;
            formatted_value_ = other.formatted_value_;
            space_name_ = other.space_name_;
            setContext(other.getContext());
        }
        return (*this);
    }

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

    static OptionDescriptorPtr create(bool persist);

    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>
        >
    >
> 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;

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 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();

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

    OptionContainerPtr getAll(const uint32_t vendor_id) 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));
        }

        // 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));
        }

        return (*od_itr);
    }

    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;

    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