network.h

Go to the documentation of this file.

// Copyright (C) 2017-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 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_option.h>
#include <dhcpsrv/cfg_4o6.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <dhcpsrv/triplet.h>
#include <util/optional.h>
#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 {

typedef std::vector<isc::asiolink::IOAddress> IOAddressList;

class Network;

typedef boost::shared_ptr<Network> NetworkPtr;

typedef boost::weak_ptr<Network> WeakNetworkPtr;

typedef std::function<data::ConstElementPtr()> 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_class_(), 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_use_conflict_resolution_() {
    }

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

    void requireClientClass(const isc::dhcp::ClientClass& class_name);

    const ClientClasses& getRequiredClasses() const;

    util::Optional<ClientClass>
    getClientClass(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getClientClass, client_class_,
                                     inheritance));
    }

    Triplet<uint32_t> getValid(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getValid, valid_, inheritance,
                                     "valid-lifetime", "min-valid-lifetime",
                                     "max-valid-lifetime"));
    }

    void setValid(const Triplet<uint32_t>& valid) {
        valid_ = valid;
    }

    Triplet<uint32_t> getT1(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT1, t1_, inheritance, "renew-timer"));
    }

    void setT1(const Triplet<uint32_t>& t1) {
        t1_ = t1;
    }

    Triplet<uint32_t> getT2(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getT2, t2_, inheritance, "rebind-timer"));
    }

    void setT2(const Triplet<uint32_t>& t2) {
        t2_ = t2;
    }

    util::Optional<bool>
    getReservationsGlobal(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getReservationsGlobal,
                                     reservations_global_,
                                     inheritance,
                                     "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,
                                     "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,
                                     "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,
                                     "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, "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, "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, "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, "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, "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, "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, "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, "ddns-qualifying-suffix"));
    }

    void setDdnsQualifyingSuffix(const util::Optional<std::string>& ddns_qualifying_suffix) {
        ddns_qualifying_suffix_ = ddns_qualifying_suffix;
    }

    util::Optional<std::string>
    getHostnameCharSet(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getHostnameCharSet, hostname_char_set_,
                                     inheritance, "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, "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, "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, "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, "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, "ddns-update-on-renew"));
    }

    void setDdnsUpdateOnRenew(const util::Optional<bool>& ddns_update_on_renew) {
        ddns_update_on_renew_ = ddns_update_on_renew;
    }

    util::Optional<bool>
    getDdnsUseConflictResolution(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network>(&Network::getDdnsUseConflictResolution,
                                     ddns_use_conflict_resolution_,
                                     inheritance, "ddns-use-conflict-resolution"));
    }

    void setDdnsUseConflictResolution(const util::Optional<bool>& ddns_use_conflict_resolution) {
        ddns_use_conflict_resolution_ = ddns_use_conflict_resolution;
    }

    virtual data::ElementPtr toElement() const;

protected:

    FetchNetworkGlobalsFn getFetchGlobalsFn() const {
        return (fetch_globals_fn_);
    }

    template<typename ReturnType>
    ReturnType getGlobalProperty(ReturnType property,
                                 const std::string& global_name,
                                 const std::string& min_name = "",
                                 const std::string& max_name = "") const {
        unused(min_name, max_name);
        if (!global_name.empty() && fetch_globals_fn_) {
            data::ConstElementPtr globals = fetch_globals_fn_();
            if (globals && (globals->getType() == data::Element::map)) {
                data::ConstElementPtr global_param = globals->get(global_name);
                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>
    Triplet<NumType> getGlobalProperty(Triplet<NumType> property,
                                       const std::string& global_name,
                                       const std::string& min_name = "",
                                       const std::string& max_name = "") const {

        if (!global_name.empty() && fetch_globals_fn_) {
            data::ConstElementPtr globals = fetch_globals_fn_();
            if (globals && (globals->getType() == data::Element::map)) {
                data::ConstElementPtr param = globals->get(global_name);
                if (param) {
                    NumType def_value = static_cast<NumType>(param->intValue());
                    if (min_name.empty() || max_name.empty()) {
                        return (def_value);
                    } else {
                        NumType min_value = def_value;
                        NumType max_value = def_value;
                        data::ConstElementPtr min_param = globals->get(min_name);
                        if (min_param) {
                            min_value = static_cast<NumType>(min_param->intValue());
                        }
                        data::ConstElementPtr max_param = globals->get(max_name);
                        if (max_param) {
                            max_value = static_cast<NumType>(max_param->intValue());
                        }
                        return (Triplet<NumType>(min_value, def_value, max_value));
                    }
                }
            }
        }
        return (property);
    }

    util::Optional<asiolink::IOAddress>
    getGlobalProperty(util::Optional<asiolink::IOAddress> property,
                      const std::string& global_name,
                      const std::string& min_name = "",
                      const std::string& max_name = "") const;

    template<typename BaseType, typename ReturnType>
    ReturnType getProperty(ReturnType(BaseType::*MethodPointer)(const Inheritance&) const,
                           ReturnType property,
                           const Inheritance& inheritance,
                           const std::string& global_name = "",
                           const std::string& min_name = "",
                           const std::string& max_name = "") 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_name, min_name, max_name));
        }

        // 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_name, min_name, max_name));
        }

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

    util::Optional<ClientClass> client_class_;

    ClientClasses required_classes_;

    Triplet<uint32_t> t1_;

    Triplet<uint32_t> t2_;

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

    WeakNetworkPtr parent_network_;

    FetchNetworkGlobalsFn fetch_globals_fn_;
};

class Network4 : public virtual Network {
public:

    Network4()
        : Network(), match_client_id_(true, true), authoritative_(),
          siaddr_(), sname_(), filename_() {
    }

    util::Optional<bool>
    getMatchClientId(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network4>(&Network4::getMatchClientId,
                                      match_client_id_,
                                      inheritance,
                                      "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, "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, "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, "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, "boot-file-name"));
    }

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

class Network6 : public virtual Network {
public:

    Network6()
        : Network(), preferred_(), interface_id_(), rapid_commit_() {
    }

    Triplet<uint32_t>
    getPreferred(const Inheritance& inheritance = Inheritance::ALL) const {
        return (getProperty<Network6>(&Network6::getPreferred, preferred_,
                                      inheritance, "preferred-lifetime",
                                      "min-preferred-lifetime",
                                      "max-preferred-lifetime"));
    }

    void setPreferred(const 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, "rapid-commit"));
    }

    void setRapidCommit(const util::Optional<bool>& rapid_commit) {
        rapid_commit_ = rapid_commit;
    };

    virtual data::ElementPtr toElement() const;

private:

    Triplet<uint32_t> preferred_;

    OptionPtr interface_id_;

    util::Optional<bool> rapid_commit_;
};

} // end of namespace isc::dhcp
} // end of namespace isc

#endif // NETWORK_H