srv_config.h

Go to the documentation of this file.

// Copyright (C) 2014-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 DHCPSRV_CONFIG_H
#define DHCPSRV_CONFIG_H
 
#include <cc/cfg_to_element.h>
#include <dhcpsrv/cfg_db_access.h>
#include <dhcpsrv/cfg_duid.h>
#include <dhcpsrv/cfg_expiration.h>
#include <dhcpsrv/cfg_globals.h>
#include <dhcpsrv/cfg_host_operations.h>
#include <dhcpsrv/cfg_hosts.h>
#include <dhcpsrv/cfg_iface.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/cfg_option_def.h>
#include <dhcpsrv/cfg_rsoo.h>
#include <dhcpsrv/cfg_shared_networks.h>
#include <dhcpsrv/cfg_subnets4.h>
#include <dhcpsrv/cfg_subnets6.h>
#include <dhcpsrv/cfg_mac_source.h>
#include <dhcpsrv/cfg_consistency.h>
#include <dhcpsrv/client_class_def.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <process/config_base.h>
#include <hooks/hooks_config.h>
#include <cc/data.h>
#include <cc/user_context.h>
#include <cc/simple_parser.h>
#include <util/optional.h>
#include <util/str.h>
 
#include <boost/shared_ptr.hpp>
#include <vector>
#include <stdint.h>
 
namespace isc {
namespace dhcp {
 
class CfgMgr;
 
class DdnsParams {
public:
    DdnsParams() : subnet_(), d2_client_enabled_(false) {};
 
    DdnsParams(const Subnet4Ptr& subnet, bool d2_client_enabled)
        : subnet_(boost::dynamic_pointer_cast<Subnet>(subnet)),
          d2_client_enabled_(d2_client_enabled) {}
 
    DdnsParams(const Subnet6Ptr& subnet, bool d2_client_enabled)
        : subnet_(boost::dynamic_pointer_cast<Subnet>(subnet)),
          d2_client_enabled_(d2_client_enabled) {}
 
    bool getEnableUpdates() const;
 
    bool getOverrideNoUpdate() const;
 
    bool getOverrideClientUpdate() const;
 
    D2ClientConfig::ReplaceClientNameMode getReplaceClientNameMode() const;
 
    std::string getGeneratedPrefix() const;
 
    std::string getQualifyingSuffix() const;
 
    std::string getHostnameCharSet() const;
 
    std::string getHostnameCharReplacement() const;
 
    isc::util::str::StringSanitizerPtr getHostnameSanitizer() const;
 
    bool getUpdateOnRenew() const;
 
    util::Optional<double> getTtlPercent() const;
 
    std::string getConflictResolutionMode() const;
 
    SubnetID getSubnetId() const {
        if (subnet_) {
            return (subnet_->getID());
        } else {
            return (0);
        }
    }
 
private:
    SubnetPtr subnet_;
 
    bool d2_client_enabled_;
};
 
typedef boost::shared_ptr<DdnsParams> DdnsParamsPtr;
 
class SrvConfig : public process::ConfigBase {
public:
 
 
    static const uint32_t CFGSEL_NONE    = 0x00000000;
    static const uint32_t CFGSEL_SUBNET4 = 0x00000001;
    static const uint32_t CFGSEL_SUBNET6 = 0x00000002;
    static const uint32_t CFGSEL_IFACE4  = 0x00000004;
    static const uint32_t CFGSEL_IFACE6  = 0x00000008;
    static const uint32_t CFGSEL_DDNS    = 0x00000010;
    static const uint32_t CFGSEL_SUBNET  = 0x00000003;
    static const uint32_t CFGSEL_GLOBALS = 0x00000020;
    static const uint32_t CFGSEL_CFG_CTL = 0x00000040;
    static const uint32_t CFGSEL_ALL4    = 0x00000035;
    static const uint32_t CFGSEL_ALL6    = 0x0000003A;
    static const uint32_t CFGSEL_ALL     = 0xFFFFFFFF;
 
    SrvConfig();
 
    SrvConfig(const uint32_t sequence);
 
    std::string getConfigSummary(const uint32_t selection) const;
 
    uint32_t getSequence() const {
        return (sequence_);
    }
 
    bool sequenceEquals(const SrvConfig& other);
 
    CfgIfacePtr getCfgIface() {
        return (cfg_iface_);
    }
 
    ConstCfgIfacePtr getCfgIface() const {
        return (cfg_iface_);
    }
 
    CfgOptionDefPtr getCfgOptionDef() {
        return (cfg_option_def_);
    }
 
    ConstCfgOptionDefPtr getCfgOptionDef() const {
        return (cfg_option_def_);
    }
 
    CfgOptionPtr getCfgOption() {
        return (cfg_option_);
    }
 
    const ConstCfgOptionPtr getCfgOption() const {
        return (cfg_option_);
    }
 
    CfgSubnets4Ptr getCfgSubnets4() {
        return (cfg_subnets4_);
    }
 
    CfgSharedNetworks4Ptr getCfgSharedNetworks4() const {
        return (cfg_shared_networks4_);
    }
 
    CfgSharedNetworks6Ptr getCfgSharedNetworks6() const {
        return (cfg_shared_networks6_);
    }
 
    ConstCfgSubnets4Ptr getCfgSubnets4() const {
        return (cfg_subnets4_);
    }
 
    CfgSubnets6Ptr getCfgSubnets6() {
        return (cfg_subnets6_);
    }
 
    ConstCfgSubnets6Ptr getCfgSubnets6() const {
        return (cfg_subnets6_);
    }
 
    CfgHostsPtr getCfgHosts() {
        return (cfg_hosts_);
    }
 
    ConstCfgHostsPtr getCfgHosts() const {
        return (cfg_hosts_);
    }
 
    CfgRSOOPtr getCfgRSOO() {
        return (cfg_rsoo_);
    }
 
    ConstCfgRSOOPtr getCfgRSOO() const {
        return (cfg_rsoo_);
    }
 
    CfgExpirationPtr getCfgExpiration() {
        return (cfg_expiration_);
    }
 
    ConstCfgExpirationPtr getCfgExpiration() const {
        return (cfg_expiration_);
    }
 
    CfgDUIDPtr getCfgDUID() {
        return (cfg_duid_);
    }
 
    ConstCfgDUIDPtr getCfgDUID() const {
        return (cfg_duid_);
    }
 
    CfgDbAccessPtr getCfgDbAccess() {
        return (cfg_db_access_);
    }
 
    ConstCfgDbAccessPtr getCfgDbAccess() const {
        return (cfg_db_access_);
    }
 
    CfgHostOperationsPtr getCfgHostOperations4() {
        return (cfg_host_operations4_);
    }
 
    ConstCfgHostOperationsPtr getCfgHostOperations4() const {
        return (cfg_host_operations4_);
    }
 
    CfgHostOperationsPtr getCfgHostOperations6() {
        return (cfg_host_operations6_);
    }
 
    ConstCfgHostOperationsPtr getCfgHostOperations6() const {
        return (cfg_host_operations6_);
    }
 
    CfgConsistencyPtr getConsistency() {
        return (cfg_consist_);
    }
 
    ConstCfgConsistencyPtr getConsistency() const {
        return (cfg_consist_);
    }
 
 
    CfgMACSource& getMACSources() {
        return (cfg_mac_source_);
    }
 
    const CfgMACSource& getMACSources() const {
        return (cfg_mac_source_);
    }
 
    const isc::data::ConstElementPtr getControlSocketInfo() const {
        return (control_socket_);
    }
 
    void setControlSocketInfo(const isc::data::ConstElementPtr& control_socket) {
        control_socket_ = control_socket;
    }
 
    const isc::data::ConstElementPtr getDHCPQueueControl() const {
        return (dhcp_queue_control_);
    }
 
    void setDHCPQueueControl(const isc::data::ConstElementPtr dhcp_queue_control) {
        dhcp_queue_control_ = dhcp_queue_control;
    }
 
    const isc::data::ConstElementPtr getDHCPMultiThreading() const {
        return (dhcp_multi_threading_);
    }
 
    void setDHCPMultiThreading(const isc::data::ConstElementPtr dhcp_multi_threading) {
        dhcp_multi_threading_ = dhcp_multi_threading;
    }
 
    ClientClassDictionaryPtr getClientClassDictionary() {
        return (class_dictionary_);
    }
 
    const ClientClassDictionaryPtr getClientClassDictionary() const {
        return (class_dictionary_);
    }
 
    void setClientClassDictionary(const ClientClassDictionaryPtr& dictionary) {
        class_dictionary_ = dictionary;
    }
 
    isc::hooks::HooksConfig& getHooksConfig() {
        return (hooks_config_);
    }
 
    const isc::hooks::HooksConfig& getHooksConfig() const {
        return (hooks_config_);
    }
 
    DdnsParamsPtr getDdnsParams(const Subnet4Ptr& subnet) const;
 
    DdnsParamsPtr getDdnsParams(const Subnet6Ptr& subnet) const;
 
    void copy(SrvConfig& new_config) const;
 
 
 
    bool equals(const SrvConfig& other) const;
 
    bool nequals(const SrvConfig& other) const {
        return (!equals(other));
    }
 
    bool operator==(const SrvConfig& other) const {
        return (equals(other));
    }
 
    bool operator!=(const SrvConfig& other) const {
        return (nequals(other));
    }
 
 
    virtual void merge(ConfigBase& other);
 
    void updateStatistics();
 
    void removeStatistics();
 
    void setDeclinePeriod(const uint32_t decline_timer) {
        decline_timer_ = decline_timer;
    }
 
    uint32_t getDeclinePeriod() const {
        return (decline_timer_);
    }
 
    void setEchoClientId(const bool echo) {
        echo_v4_client_id_ = echo;
    }
 
    bool getEchoClientId() const {
        return (echo_v4_client_id_);
    }
 
    void setDhcp4o6Port(uint16_t port) {
        dhcp4o6_port_ = port;
    }
 
    uint16_t getDhcp4o6Port() const {
        return (dhcp4o6_port_);
    }
 
    D2ClientConfigPtr getD2ClientConfig() {
        return (d2_client_config_);
    }
 
    const D2ClientConfigPtr getD2ClientConfig() const {
        return (d2_client_config_);
    }
 
    void setD2ClientConfig(const D2ClientConfigPtr& d2_client_config) {
        d2_client_config_ = d2_client_config;
    }
 
    CfgGlobalsPtr getConfiguredGlobals() {
        return (configured_globals_);
    }
 
    ConstCfgGlobalsPtr getConfiguredGlobals() const {
        return (configured_globals_);
    }
 
    isc::data::ConstElementPtr getConfiguredGlobal(std::string name) const {
        return (configured_globals_->get(name));
    }
 
    isc::data::ConstElementPtr getConfiguredGlobal(int index) const {
        return (configured_globals_->get(index));
    }
 
    void clearConfiguredGlobals() {
        configured_globals_->clear();
        lenient_option_parsing_ = false;
        ignore_dhcp_server_identifier_ = false;
        ignore_rai_link_selection_ = false;
        exclude_first_last_24_ = false;
        control_socket_.reset();
        d2_client_config_.reset(new D2ClientConfig());
        cfg_expiration_.reset(new CfgExpiration());
        dhcp_multi_threading_.reset();
        cfg_consist_.reset(new CfgConsistency());
        cfg_duid_.reset(new CfgDUID());
        dhcp_queue_control_.reset();
    }
 
    void applyDefaultsConfiguredGlobals(const isc::data::SimpleDefaults& defaults);
 
    void extractConfiguredGlobals(isc::data::ConstElementPtr config);
 
    void addConfiguredGlobal(const std::string& name, isc::data::ConstElementPtr value) {
        configured_globals_->set(name, value);
    }
 
    void sanityChecksLifetime(const std::string& name) const;
 
    void sanityChecksLifetime(const SrvConfig& target_config,
                              const std::string& name) const;
 
    void setIPReservationsUnique(const bool unique);
 
    void setReservationsLookupFirst(const bool first) {
        reservations_lookup_first_ = first;
    }
 
    bool getReservationsLookupFirst() const {
        return (reservations_lookup_first_);
    }
 
    virtual isc::data::ElementPtr toElement() const;
 
    void setLenientOptionParsing(bool const value) {
        lenient_option_parsing_ = value;
    }
 
    bool getLenientOptionParsing() const {
        return lenient_option_parsing_;
    }
 
    void setIgnoreServerIdentifier(bool const value) {
        ignore_dhcp_server_identifier_ = value;
    }
 
    bool getIgnoreServerIdentifier() const {
        return (ignore_dhcp_server_identifier_);
    }
 
    void setIgnoreRAILinkSelection(bool const value) {
        ignore_rai_link_selection_ = value;
    }
 
    bool getIgnoreRAILinkSelection() const {
        return ignore_rai_link_selection_;
    }
 
    void setExcludeFirstLast24(bool const value) {
        exclude_first_last_24_ = value;
    }
 
    bool getExcludeFirstLast24() const {
        return exclude_first_last_24_;
    }
 
    void configureLowerLevelLibraries() const;
 
private:
 
    void merge4(SrvConfig& other);
 
    void merge6(SrvConfig& other);
 
    void mergeGlobals(SrvConfig& other);
 
    void mergeGlobalMaps(SrvConfig& other);
 
    uint32_t sequence_;
 
    CfgIfacePtr cfg_iface_;
 
    CfgOptionDefPtr cfg_option_def_;
 
    CfgOptionPtr cfg_option_;
 
    CfgSubnets4Ptr cfg_subnets4_;
 
    CfgSubnets6Ptr cfg_subnets6_;
 
    CfgSharedNetworks4Ptr cfg_shared_networks4_;
 
    CfgSharedNetworks6Ptr cfg_shared_networks6_;
 
    CfgHostsPtr cfg_hosts_;
 
    CfgMACSource cfg_mac_source_;
 
    CfgRSOOPtr cfg_rsoo_;
 
    CfgExpirationPtr cfg_expiration_;
 
    CfgDUIDPtr cfg_duid_;
 
    CfgDbAccessPtr cfg_db_access_;
 
    CfgHostOperationsPtr cfg_host_operations4_;
 
    CfgHostOperationsPtr cfg_host_operations6_;
 
    isc::data::ConstElementPtr control_socket_;
 
    isc::data::ConstElementPtr dhcp_queue_control_;
 
    isc::data::ConstElementPtr dhcp_multi_threading_;
 
    ClientClassDictionaryPtr class_dictionary_;
 
    isc::hooks::HooksConfig hooks_config_;
 
    uint32_t decline_timer_;
 
    bool echo_v4_client_id_;
 
    uint16_t dhcp4o6_port_;
 
    D2ClientConfigPtr d2_client_config_;
 
    CfgGlobalsPtr configured_globals_;
 
    CfgConsistencyPtr cfg_consist_;
 
 
 
    bool lenient_option_parsing_;
    bool ignore_dhcp_server_identifier_;
    bool ignore_rai_link_selection_;
    bool exclude_first_last_24_;
 
    bool reservations_lookup_first_;
};
 
 
 
typedef boost::shared_ptr<SrvConfig> SrvConfigPtr;
 
typedef boost::shared_ptr<const SrvConfig> ConstSrvConfigPtr;
 
}  // namespace dhcp
}  // namespace isc
 
#endif // DHCPSRV_CONFIG_H