network.h

Go to the documentation of this file.

// Copyright (C) 2017-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 NETWORK_H
#define NETWORK_H
 
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <cc/element_value.h>
#include <cc/stamped_element.h>
#include <cc/user_context.h>
#include <dhcp/classify.h>
#include <dhcp/option.h>
#include <dhcpsrv/cfg_globals.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/cfg_4o6.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <util/triplet.h>
#include <util/optional.h>
 
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
 
#include <cstdint>
#include <functional>
#include <string>
 
namespace {
template <typename... Args>
inline void unused(Args const& ...) {}
} // end of anonymous namespace
 
namespace isc {
namespace dhcp {
 
struct IOAddressListListTag { };
 
struct IOAddressListSetTag { };
 
typedef boost::multi_index_container<
    // Multi index container holds IO addresses.
    asiolink::IOAddress,
    // Indexes.
    boost::multi_index::indexed_by<
        // First and default index allows for in order iteration.
        boost::multi_index::sequenced<
            boost::multi_index::tag<IOAddressListListTag>
        >,
        // Second index allows for checking existence.
        boost::multi_index::hashed_unique<
            boost::multi_index::tag<IOAddressListSetTag>,
            boost::multi_index::identity<asiolink::IOAddress>
        >
    >
> IOAddressList;
 
// @brief Forward declaration of the Network class.
class Network;
 
typedef boost::shared_ptr<Network> NetworkPtr;
 
typedef boost::weak_ptr<Network> WeakNetworkPtr;
 
typedef std::function<ConstCfgGlobalsPtr()> FetchNetworkGlobalsFn;
 
class Network : public virtual isc::data::StampedElement,
                public virtual isc::data::UserContext,
                public isc::data::CfgToElement {
public:
    class RelayInfo {
    public:
 
        void addAddress(const asiolink::IOAddress& addr);
 
        const IOAddressList& getAddresses() const;
 
        bool hasAddresses() const;
 
        bool containsAddress(const asiolink::IOAddress& addr) const;
 
    private:
        IOAddressList addresses_;
    };
 
    enum class Inheritance {
        NONE,
        PARENT_NETWORK,
        GLOBAL,
        ALL
    };
 
    typedef boost::shared_ptr<Network::RelayInfo> RelayInfoPtr;
 
    Network()
        : iface_name_(), client_classes_(), t1_(), t2_(), valid_(),
          reservations_global_(false, true), reservations_in_subnet_(true, true),
          reservations_out_of_pool_(false, true), cfg_option_(new CfgOption()),
          calculate_tee_times_(), t1_percent_(), t2_percent_(),
          ddns_send_updates_(), ddns_override_no_update_(), ddns_override_client_update_(),
          ddns_replace_client_name_mode_(), ddns_generated_prefix_(), ddns_qualifying_suffix_(),
          hostname_char_set_(), hostname_char_replacement_(), store_extended_info_(),
          cache_threshold_(), cache_max_age_(), ddns_update_on_renew_(),
          ddns_conflict_resolution_mode_(), ddns_ttl_percent_(), 
          ddns_ttl_(), ddns_ttl_min_(), ddns_ttl_max_(),
          allocator_type_(), default_allocator_type_() {
    }
 
    virtual ~Network() { }
 
    void setFetchGlobalsFn(FetchNetworkGlobalsFn fetch_globals_fn) {
        fetch_globals_fn_ = fetch_globals_fn;
    }
 
    bool hasFetchGlobalsFn() const {
        return (static_cast<bool>(fetch_globals_fn_));
    }
 
    void setIface(const util::Optional<std::string>& iface_name) {
        if (iface_name.empty()) {
            iface_name_ = util::Optional<std::string>("", true);
        } else {
            iface_name_ = iface_name;
        }
    }
 
    util::Optional<std::string>
    getIface(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getIface, iface_name_,
                                     inheritance));
    }
 
    void setRelayInfo(const RelayInfo& relay) {
        relay_ = relay;
    }
 
    const RelayInfo& getRelayInfo() const {
        return (relay_);
    }
 
    void addRelayAddress(const asiolink::IOAddress& addr);
 
    const IOAddressList& getRelayAddresses() const;
 
    bool hasRelays() const;
 
    bool hasRelayAddress(const asiolink::IOAddress& address) const;
 
    virtual bool
    clientSupported(const isc::dhcp::ClientClasses& client_classes) const;
 
    void allowClientClass(const isc::dhcp::ClientClass& class_name);
 
    const ClientClasses& getClientClasses() const {
        return (client_classes_);
    }
 
    ClientClasses& getMutableClientClasses() {
        return (client_classes_);
    }
 
    void addAdditionalClass(const isc::dhcp::ClientClass& class_name);
 
    const ClientClasses& getAdditionalClasses() const {
        return (additional_classes_);
    }
 
    ClientClasses& getMutableAdditionalClasses() {
        return (additional_classes_);
    }
 
    isc::util::Triplet<uint32_t> getValid(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getValid, valid_, inheritance,
                                     CfgGlobals::VALID_LIFETIME,
                                     CfgGlobals::MIN_VALID_LIFETIME,
                                     CfgGlobals::MAX_VALID_LIFETIME));
    }
 
    void setValid(const isc::util::Triplet<uint32_t>& valid) {
        valid_ = valid;
    }
 
    isc::util::Triplet<uint32_t> getT1(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT1, t1_, inheritance,
                                     CfgGlobals::RENEW_TIMER));
    }
 
    void setT1(const isc::util::Triplet<uint32_t>& t1) {
        t1_ = t1;
    }
 
    isc::util::Triplet<uint32_t> getT2(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT2, t2_, inheritance,
                                     CfgGlobals::REBIND_TIMER));
    }
 
    void setT2(const isc::util::Triplet<uint32_t>& t2) {
        t2_ = t2;
    }
 
    util::Optional<bool>
    getReservationsGlobal(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getReservationsGlobal,
                                     reservations_global_,
                                     inheritance,
                                     CfgGlobals::RESERVATIONS_GLOBAL));
    }
 
    void setReservationsGlobal(const util::Optional<bool>& reservations_global) {
        reservations_global_ = reservations_global;
    }
 
    util::Optional<bool>
    getReservationsInSubnet(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getReservationsInSubnet,
                                     reservations_in_subnet_,
                                     inheritance,
                                     CfgGlobals::RESERVATIONS_IN_SUBNET));
    }
 
    void setReservationsInSubnet(const util::Optional<bool>& reservations_in_subnet) {
        reservations_in_subnet_ = reservations_in_subnet;
    }
 
    util::Optional<bool>
    getReservationsOutOfPool(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getReservationsOutOfPool,
                                     reservations_out_of_pool_,
                                     inheritance,
                                     CfgGlobals::RESERVATIONS_OUT_OF_POOL));
    }
 
    void setReservationsOutOfPool(const util::Optional<bool>& reservations_out_of_pool) {
        reservations_out_of_pool_ = reservations_out_of_pool;
    }
 
    CfgOptionPtr getCfgOption() {
        return (cfg_option_);
    }
 
    ConstCfgOptionPtr getCfgOption() const {
        return (cfg_option_);
    }
 
    util::Optional<bool>
    getCalculateTeeTimes(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getCalculateTeeTimes,
                                     calculate_tee_times_,
                                     inheritance,
                                     CfgGlobals::CALCULATE_TEE_TIMES));
    }
 
    void setCalculateTeeTimes(const util::Optional<bool>& calculate_tee_times) {
        calculate_tee_times_ = calculate_tee_times;
    }
 
    util::Optional<double>
    getT1Percent(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT1Percent, t1_percent_,
                                     inheritance, CfgGlobals::T1_PERCENT));
    }
 
    void setT1Percent(const util::Optional<double>& t1_percent) {
        t1_percent_ = t1_percent;
    }
 
    util::Optional<double>
    getT2Percent(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT2Percent, t2_percent_,
                                     inheritance, CfgGlobals::T2_PERCENT));
    }
 
    void setT2Percent(const util::Optional<double>& t2_percent) {
        t2_percent_ = t2_percent;
    }
 
    util::Optional<bool>
    getDdnsSendUpdates(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsSendUpdates,
                                     ddns_send_updates_, inheritance,
                                     CfgGlobals::DDNS_SEND_UPDATES));
    }
 
    void setDdnsSendUpdates(const util::Optional<bool>& ddns_send_updates) {
        ddns_send_updates_ = ddns_send_updates;
    }
 
    util::Optional<bool>
    getDdnsOverrideNoUpdate(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsOverrideNoUpdate,
                                     ddns_override_no_update_, inheritance,
                                     CfgGlobals::DDNS_OVERRIDE_NO_UPDATE));
    }
 
    void setDdnsOverrideNoUpdate(const util::Optional<bool>& ddns_override_no_update) {
        ddns_override_no_update_ = ddns_override_no_update;
    }
 
    util::Optional<bool>
    getDdnsOverrideClientUpdate(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsOverrideClientUpdate,
                                     ddns_override_client_update_, inheritance,
                                     CfgGlobals::DDNS_OVERRIDE_CLIENT_UPDATE));
    }
 
    void setDdnsOverrideClientUpdate(const util::Optional<bool>&
                                     ddns_override_client_update) {
        ddns_override_client_update_ = ddns_override_client_update;
    }
 
    util::Optional<D2ClientConfig::ReplaceClientNameMode>
    getDdnsReplaceClientNameMode(const Inheritance& inheritance = Inheritance::ALL) const {
        // Inheritance for ddns-replace-client-name is a little different than for other
        // parameters. The value at the global level is given as a string.
        // Thus we call getProperty here without a global name to check if it
        // is specified on network level only.
        const util::Optional<D2ClientConfig::ReplaceClientNameMode>& mode =
            getProperty<Network>(&Network::getDdnsReplaceClientNameMode,
                                 ddns_replace_client_name_mode_, inheritance);
 
        // If it is not specified at network level we need this special
        // case code to convert the global string value to an enum.
        if (mode.unspecified() && (inheritance != Inheritance::NONE) &&
            (inheritance != Inheritance::PARENT_NETWORK)) {
            // Get global mode.
            util::Optional<std::string> mode_label;
            mode_label = getGlobalProperty(mode_label,
                                           CfgGlobals::DDNS_REPLACE_CLIENT_NAME);
            if (!mode_label.unspecified()) {
                try {
                    // If the mode is globally configured, convert it to an enum.
                    return (D2ClientConfig::stringToReplaceClientNameMode(mode_label.get()));
                } catch (...) {
                    // This should not really happen because the configuration
                    // parser should have already verified the globally configured
                    // mode. However, we want to be 100% sure that this
                    // method doesn't throw. Let's just return unspecified.
                    return (mode);
                }
            }
        }
        return (mode);
    }
 
    void
    setDdnsReplaceClientNameMode(const util::Optional<D2ClientConfig::ReplaceClientNameMode>&
                                 ddns_replace_client_name_mode) {
        ddns_replace_client_name_mode_ = ddns_replace_client_name_mode;
    }
 
    util::Optional<std::string>
    getDdnsGeneratedPrefix(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsGeneratedPrefix,
                                     ddns_generated_prefix_, inheritance,
                                     CfgGlobals::DDNS_GENERATED_PREFIX));
    }
 
    void setDdnsGeneratedPrefix(const util::Optional<std::string>& ddns_generated_prefix) {
        ddns_generated_prefix_ = ddns_generated_prefix;
    }
 
    util::Optional<std::string>
    getDdnsQualifyingSuffix(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsQualifyingSuffix,
                                     ddns_qualifying_suffix_, inheritance,
                                     CfgGlobals::DDNS_QUALIFYING_SUFFIX));
    }
 
    void setDdnsQualifyingSuffix(const util::Optional<std::string>& ddns_qualifying_suffix) {
        ddns_qualifying_suffix_ = ddns_qualifying_suffix;
    }
 
    util::Optional<double>
    getDdnsTtlPercent(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsTtlPercent,
                                     ddns_ttl_percent_, inheritance,
                                     CfgGlobals::DDNS_TTL_PERCENT));
    }
 
    void setDdnsTtlPercent(const util::Optional<double>& ddns_ttl_percent) {
        ddns_ttl_percent_ = ddns_ttl_percent;
    }
 
 
    util::Optional<uint32_t>
    getDdnsTtl(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsTtl,
                                     ddns_ttl_, inheritance,
                                     CfgGlobals::DDNS_TTL));
    }
 
    void setDdnsTtl(const util::Optional<uint32_t>& ddns_ttl) {
        ddns_ttl_ = ddns_ttl;
    }
 
 
    util::Optional<uint32_t>
    getDdnsTtlMin(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsTtlMin,
                                     ddns_ttl_min_, inheritance,
                                     CfgGlobals::DDNS_TTL_MIN));
    }
 
    void setDdnsTtlMin(const util::Optional<uint32_t>& ddns_ttl_min) {
        ddns_ttl_min_ = ddns_ttl_min;
    }
 
    util::Optional<uint32_t>
    getDdnsTtlMax(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsTtlMax,
                                     ddns_ttl_max_, inheritance,
                                     CfgGlobals::DDNS_TTL_MAX));
    }
 
    void setDdnsTtlMax(const util::Optional<uint32_t>& ddns_ttl_max) {
        ddns_ttl_max_ = ddns_ttl_max;
    }
 
    util::Optional<std::string>
    getHostnameCharSet(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getHostnameCharSet,
                                     hostname_char_set_, inheritance,
                                     CfgGlobals::HOSTNAME_CHAR_SET));
    }
 
    void setHostnameCharSet(const util::Optional<std::string>& hostname_char_set) {
        hostname_char_set_ = hostname_char_set;
    }
 
    util::Optional<std::string>
    getHostnameCharReplacement(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getHostnameCharReplacement,
                                     hostname_char_replacement_, inheritance,
                                     CfgGlobals::HOSTNAME_CHAR_REPLACEMENT));
    }
 
    void setHostnameCharReplacement(const util::Optional<std::string>&
                                    hostname_char_replacement) {
        hostname_char_replacement_ = hostname_char_replacement;
    }
 
    util::Optional<bool>
    getStoreExtendedInfo(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getStoreExtendedInfo,
                                     store_extended_info_, inheritance,
                                     CfgGlobals::STORE_EXTENDED_INFO));
    }
 
    void setStoreExtendedInfo(const util::Optional<bool>& store_extended_info) {
        store_extended_info_ = store_extended_info;
    }
 
    util::Optional<double>
    getCacheThreshold(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getCacheThreshold,
                                     cache_threshold_, inheritance,
                                     CfgGlobals::CACHE_THRESHOLD));
    }
 
    void setCacheThreshold(const util::Optional<double>& cache_threshold) {
        cache_threshold_ = cache_threshold;
    }
 
    util::Optional<uint32_t>
    getCacheMaxAge(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getCacheMaxAge, cache_max_age_,
                                     inheritance, CfgGlobals::CACHE_MAX_AGE));
    }
 
    void setCacheMaxAge(const util::Optional<uint32_t>& cache_max_age) {
        cache_max_age_ = cache_max_age;
    }
 
    util::Optional<bool>
    getDdnsUpdateOnRenew(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsUpdateOnRenew,
                                     ddns_update_on_renew_, inheritance,
                                     CfgGlobals::DDNS_UPDATE_ON_RENEW));
    }
 
    void setDdnsUpdateOnRenew(const util::Optional<bool>& ddns_update_on_renew) {
        ddns_update_on_renew_ = ddns_update_on_renew;
    }
 
 
    util::Optional<std::string>
    getDdnsConflictResolutionMode(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsConflictResolutionMode,
                                     ddns_conflict_resolution_mode_,
                                     inheritance,
                                     CfgGlobals::DDNS_CONFLICT_RESOLUTION_MODE));
    }
 
    void setDdnsConflictResolutionMode(const util::Optional<std::string>& ddns_conflict_resolution_mode) {
        ddns_conflict_resolution_mode_ = ddns_conflict_resolution_mode;
    }
 
    util::Optional<std::string>
    getAllocatorType(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getAllocatorType,
                                     allocator_type_,
                                     inheritance,
                                     CfgGlobals::ALLOCATOR));
    }
 
    void setAllocatorType(const util::Optional<std::string>& allocator_type) {
        allocator_type_ = allocator_type;
    }
 
    util::Optional<std::string>
    getDefaultAllocatorType(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDefaultAllocatorType,
                                     default_allocator_type_,
                                     inheritance));
    }
 
    void setDefaultAllocatorType(const std::string& allocator_type) {
        default_allocator_type_ = allocator_type;
    }
 
    virtual data::ElementPtr toElement() const;
 
    virtual std::string getLabel() const {
        return ("base-network");
    }
 
protected:
 
    FetchNetworkGlobalsFn getFetchGlobalsFn() const {
        return (fetch_globals_fn_);
    }
 
    template<typename ReturnType>
    ReturnType getGlobalProperty(ReturnType property,
                                 const int global_index,
                                 const int min_index = -1,
                                 const int max_index = -1) const {
        unused(min_index, max_index);
        if ((global_index >= 0) && fetch_globals_fn_) {
            ConstCfgGlobalsPtr globals = fetch_globals_fn_();
            if (globals) {
                data::ConstElementPtr global_param = globals->get(global_index);
                if (global_param) {
                    // If there is a global parameter, convert it to the
                    // optional value of the given type and return.
                    return (data::ElementValue<typename ReturnType::ValueType>()(global_param));
                }
            }
        }
        return (property);
    }
 
    template<typename NumType>
    isc::util::Triplet<NumType> getGlobalProperty(isc::util::Triplet<NumType> property,
                                                  const int global_index,
                                                  const int min_index = -1,
                                                  const int max_index = -1) const {
 
        if ((global_index >= 0) && fetch_globals_fn_) {
            ConstCfgGlobalsPtr globals = fetch_globals_fn_();
            if (globals) {
                data::ConstElementPtr param = globals->get(global_index);
                if (param) {
                    NumType def_value = static_cast<NumType>(param->intValue());
                    if ((min_index < 0) || (max_index < 0)) {
                        return (def_value);
                    } else {
                        NumType min_value = def_value;
                        NumType max_value = def_value;
                        data::ConstElementPtr min_param = globals->get(min_index);
                        if (min_param) {
                            min_value = static_cast<NumType>(min_param->intValue());
                        }
                        data::ConstElementPtr max_param = globals->get(max_index);
                        if (max_param) {
                            max_value = static_cast<NumType>(max_param->intValue());
                        }
                        return (isc::util::Triplet<NumType>(min_value, def_value, max_value));
                    }
                }
            }
        }
        return (property);
    }
 
    util::Optional<asiolink::IOAddress>
    getGlobalProperty(util::Optional<asiolink::IOAddress> property,
                      const int global_index,
                      const int min_index = -1,
                      const int max_index = -1) const;
 
    template<typename BaseType, typename ReturnType>
    ReturnType getProperty(ReturnType(BaseType::*MethodPointer)(const Inheritance&) const,
                           ReturnType property,
                           const Inheritance& inheritance,
                           const int global_index = -1,
                           const int min_index = -1,
                           const int max_index = -1) const {
 
        // If no inheritance is to be used, return the value for this
        // network regardless if it is specified or not.
        if (inheritance == Inheritance::NONE) {
            return (property);
 
        } else if (inheritance == Inheritance::PARENT_NETWORK) {
            ReturnType parent_property;
 
            // Check if this instance has a parent network.
            auto parent = boost::dynamic_pointer_cast<BaseType>(parent_network_.lock());
            if (parent) {
                parent_property = ((*parent).*MethodPointer)(Network::Inheritance::NONE);
            }
            return (parent_property);
 
        // If global value requested, return it.
        } else if (inheritance == Inheritance::GLOBAL) {
            return (getGlobalProperty(ReturnType(), global_index, min_index, max_index));
        }
 
        // We use inheritance and the value is not specified on the network level.
        // Hence, we need to get the parent network specific value or global value.
        if (property.unspecified()) {
            // Check if this instance has a parent network.
            auto parent = boost::dynamic_pointer_cast<BaseType>(parent_network_.lock());
            // If the parent network exists, let's fetch the parent specific
            // value.
            if (parent) {
                // We're using inheritance so ask for the parent specific network
                // and return it only if it is specified.
                auto parent_property = ((*parent).*MethodPointer)(inheritance);
                if (!parent_property.unspecified()) {
                    return (parent_property);
                }
            }
 
            // The value is not specified on network level. If the value
            // can be specified on global level and there is a callback
            // that returns the global values, try to find this parameter
            // at the global scope.
            return (getGlobalProperty(property, global_index, min_index, max_index));
        }
 
        // We haven't found the value at any level, so return the unspecified.
        return (property);
    }
 
    template<typename BaseType>
    OptionPtr
    getOptionProperty(OptionPtr(BaseType::*MethodPointer)(const Inheritance& inheritance) const,
                      OptionPtr property,
                      const Inheritance& inheritance) const {
        if (inheritance == Network::Inheritance::NONE) {
            return (property);
 
        } else if (inheritance == Network::Inheritance::PARENT_NETWORK) {
            OptionPtr parent_property;
            // Check if this instance has a parent network.
            auto parent = boost::dynamic_pointer_cast<BaseType>(parent_network_.lock());
            // If the parent network exists, let's fetch the parent specific
            // value.
            if (parent) {
                parent_property = ((*parent).*MethodPointer)(Network::Inheritance::NONE);
            }
            return (parent_property);
 
        } else if (inheritance == Network::Inheritance::GLOBAL) {
            return (OptionPtr());
        }
 
        // We use inheritance and the value is not specified on the network level.
        // Hence, we need to get the parent network specific value.
        if (!property) {
            // Check if this instance has a parent network.
            auto parent = boost::dynamic_pointer_cast<BaseType>(parent_network_.lock());
            if (parent) {
                // We're using inheritance so ask for the parent specific network
                // and return it only if it is specified.
                OptionPtr parent_property = (((*parent).*MethodPointer)(inheritance));
                if (parent_property) {
                    return (parent_property);
                }
            }
        }
 
        // We haven't found the value at any level, so return the unspecified.
        return (property);
    }
 
    util::Optional<std::string> iface_name_;
 
    RelayInfo relay_;
 
    ClientClasses client_classes_;
 
    ClientClasses additional_classes_;
 
    isc::util::Triplet<uint32_t> t1_;
 
    isc::util::Triplet<uint32_t> t2_;
 
    isc::util::Triplet<uint32_t> valid_;
 
    util::Optional<bool> reservations_global_;
 
    util::Optional<bool> reservations_in_subnet_;
 
    util::Optional<bool> reservations_out_of_pool_;
 
    CfgOptionPtr cfg_option_;
 
    util::Optional<bool> calculate_tee_times_;
 
    util::Optional<double> t1_percent_;
 
    util::Optional<double> t2_percent_;
 
    util::Optional<bool> ddns_send_updates_;
 
    util::Optional<bool> ddns_override_no_update_;
 
    util::Optional<bool> ddns_override_client_update_;
 
    util::Optional<D2ClientConfig::ReplaceClientNameMode> ddns_replace_client_name_mode_;
 
    util::Optional<std::string> ddns_generated_prefix_;
 
    util::Optional<std::string> ddns_qualifying_suffix_;
 
    util::Optional<std::string> hostname_char_set_;
 
    util::Optional<std::string> hostname_char_replacement_;
 
    util::Optional<bool> store_extended_info_;
 
    util::Optional<double> cache_threshold_;
 
    util::Optional<uint32_t> cache_max_age_;
 
    util::Optional<bool> ddns_update_on_renew_;
 
    util::Optional<std::string> ddns_conflict_resolution_mode_;
 
    util::Optional<double> ddns_ttl_percent_;
 
    util::Optional<uint32_t> ddns_ttl_;
 
    util::Optional<uint32_t> ddns_ttl_min_;
 
    util::Optional<uint32_t> ddns_ttl_max_;
 
    util::Optional<std::string> allocator_type_;
 
    util::Optional<std::string> default_allocator_type_;
 
    WeakNetworkPtr parent_network_;
 
    FetchNetworkGlobalsFn fetch_globals_fn_;
};
 
class Network4 : public virtual Network {
public:
 
    Network4()
        : Network(), match_client_id_(true, true), authoritative_(),
          siaddr_(), sname_(), filename_(), offer_lft_() {
    }
 
    util::Optional<bool>
    getMatchClientId(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getMatchClientId,
                                      match_client_id_,
                                      inheritance,
                                      CfgGlobals::MATCH_CLIENT_ID));
    }
 
    void setMatchClientId(const util::Optional<bool>& match) {
        match_client_id_ = match;
    }
 
    util::Optional<bool>
    getAuthoritative(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getAuthoritative,
                                      authoritative_, inheritance,
                                      CfgGlobals::AUTHORITATIVE));
    }
 
    void setAuthoritative(const util::Optional<bool>& authoritative) {
        authoritative_ = authoritative;
    }
 
    void setSiaddr(const util::Optional<asiolink::IOAddress>& siaddr);
 
    util::Optional<asiolink::IOAddress>
    getSiaddr(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getSiaddr, siaddr_,
                                      inheritance, CfgGlobals::NEXT_SERVER));
    }
 
    void setSname(const util::Optional<std::string>& sname);
 
    util::Optional<std::string>
    getSname(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getSname, sname_,
                                      inheritance,
                                      CfgGlobals::SERVER_HOSTNAME));
    }
 
    void setFilename(const util::Optional<std::string>& filename);
 
    util::Optional<std::string>
    getFilename(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getFilename, filename_,
                                      inheritance,
                                      CfgGlobals::BOOT_FILE_NAME));
    }
 
    void setOfferLft(const util::Optional<uint32_t>& offer_lft) {
        offer_lft_ = offer_lft;
    }
 
    util::Optional<uint32_t>
    getOfferLft(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getOfferLft, offer_lft_,
                                      inheritance,
                                      CfgGlobals::OFFER_LIFETIME));
    }
 
    virtual data::ElementPtr toElement() const;
 
    virtual asiolink::IOAddress getServerId() const;
 
private:
 
    util::Optional<bool> match_client_id_;
 
    util::Optional<bool> authoritative_;
 
    util::Optional<asiolink::IOAddress> siaddr_;
 
    util::Optional<std::string> sname_;
 
    util::Optional<std::string> filename_;
 
    util::Optional<uint32_t> offer_lft_;
};
 
typedef boost::shared_ptr<Network4> Network4Ptr;
 
class Network6;
 
typedef boost::shared_ptr<Network6> Network6Ptr;
 
class Network6 : public virtual Network {
public:
 
    Network6()
        : Network(), preferred_(), interface_id_(), rapid_commit_(),
          default_pd_allocator_type_(){
    }
 
    isc::util::Triplet<uint32_t>
    getPreferred(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network6>(&Network6::getPreferred, preferred_,
                                      inheritance,
                                      CfgGlobals::PREFERRED_LIFETIME,
                                      CfgGlobals::MIN_PREFERRED_LIFETIME,
                                      CfgGlobals::MAX_PREFERRED_LIFETIME));
    }
 
    void setPreferred(const isc::util::Triplet<uint32_t>& preferred) {
        preferred_ = preferred;
    }
 
    OptionPtr getInterfaceId(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getOptionProperty<Network6>(&Network6::getInterfaceId, interface_id_,
                                            inheritance));
    }
 
    void setInterfaceId(const OptionPtr& ifaceid) {
        interface_id_ = ifaceid;
    }
 
    util::Optional<bool>
    getRapidCommit(const Inheritance& inheritance = Inheritance::ALL) const {
 
        return (getProperty<Network6>(&Network6::getRapidCommit, rapid_commit_,
                                      inheritance));
    }
 
    void setRapidCommit(const util::Optional<bool>& rapid_commit) {
        rapid_commit_ = rapid_commit;
    }
 
    util::Optional<std::string>
    getPdAllocatorType(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network6>(&Network6::getPdAllocatorType,
                                      pd_allocator_type_,
                                      inheritance,
                                      CfgGlobals::PD_ALLOCATOR));
    }
 
    void setPdAllocatorType(const util::Optional<std::string>& allocator_type) {
        pd_allocator_type_ = allocator_type;
    }
 
    util::Optional<std::string>
    getDefaultPdAllocatorType(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network6>(&Network6::getDefaultPdAllocatorType,
                                      default_pd_allocator_type_,
                                      inheritance));
    }
 
    void setDefaultPdAllocatorType(const std::string& allocator_type) {
        default_pd_allocator_type_ = allocator_type;
    }
 
    virtual data::ElementPtr toElement() const;
 
private:
 
    isc::util::Triplet<uint32_t> preferred_;
 
    OptionPtr interface_id_;
 
    util::Optional<bool> rapid_commit_;
 
    util::Optional<std::string> pd_allocator_type_;
 
    // @brief Default allocator type for prefix delegation.
    util::Optional<std::string> default_pd_allocator_type_;
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // NETWORK_H