srv_config.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 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_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/strutil.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;

    bool getUseConflictResolution() 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_);
    }


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

    isc::data::ConstElementPtr getConfiguredGlobals() const {
        return (isc::data::ConstElementPtr(configured_globals_));
    }

    isc::data::ConstElementPtr getConfiguredGlobal(std::string name) const;

    void clearConfiguredGlobals();

    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;

    static void moveDdnsParams(isc::data::ElementPtr srv_elem);

    void setIPReservationsUnique(const bool unique);

    virtual isc::data::ElementPtr toElement() const;

    void setLenientOptionParsing(bool const value) {
        lenient_option_parsing_ = value;
    }

    bool getLenientOptionParsing() const {
        return lenient_option_parsing_;
    }

    void configureLowerLevelLibraries() const;

private:

    void merge4(SrvConfig& other);

    void merge6(SrvConfig& other);

    void mergeGlobals(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_;

    isc::data::ElementPtr configured_globals_;

    CfgConsistencyPtr cfg_consist_;

    bool lenient_option_parsing_;
};


typedef boost::shared_ptr<SrvConfig> SrvConfigPtr;

typedef boost::shared_ptr<const SrvConfig> ConstSrvConfigPtr;

}  // namespace dhcp
}  // namespace isc

#endif // DHCPSRV_CONFIG_H