34#include <boost/make_shared.hpp> 
   47    : sequence_(0), cfg_iface_(new 
CfgIface()),
 
   58      decline_timer_(0), echo_v4_client_id_(true), dhcp4o6_port_(0),
 
   61      lenient_option_parsing_(false), ignore_dhcp_server_identifier_(false),
 
   62      ignore_rai_link_selection_(false), exclude_first_last_24_(false),
 
   63      reservations_lookup_first_(false) {
 
 
   67    : sequence_(sequence), cfg_iface_(new 
CfgIface()),
 
   78      decline_timer_(0), echo_v4_client_id_(true), dhcp4o6_port_(0),
 
   81      lenient_option_parsing_(false), ignore_dhcp_server_identifier_(false),
 
   82      ignore_rai_link_selection_(false), exclude_first_last_24_(false),
 
   83      reservations_lookup_first_(false) {
 
 
   92        if (subnets_num > 0) {
 
   93            s << 
"added IPv4 subnets: " << subnets_num;
 
   95            s << 
"no IPv4 subnets!";
 
  102        if (subnets_num > 0) {
 
  103            s << 
"added IPv6 subnets: " << subnets_num;
 
  105            s << 
"no IPv6 subnets!";
 
  112        s << 
"DDNS: " << (ddns_enabled ? 
"enabled" : 
"disabled") << 
"; ";
 
  115    if (s.tellp() == 
static_cast<std::streampos
>(0)) {
 
  116        s << 
"no config details available";
 
  119    std::string summary = s.str();
 
  120    size_t last_separator_pos = summary.find_last_of(
";");
 
  121    if (last_separator_pos == summary.length() - 2) {
 
  122        summary.erase(last_separator_pos);
 
 
  137    new_config.cfg_iface_.reset(
new CfgIface(*cfg_iface_));
 
  139    cfg_option_def_->copyTo(*new_config.cfg_option_def_);
 
  140    cfg_option_->copyTo(*new_config.cfg_option_);
 
  146    new_config.hooks_config_.
clear();
 
  148    for (
auto const& it : hooks_config_.get()) {
 
  149        new_config.hooks_config_.
add(it.libname_, it.parameters_, it.cfgname_);
 
 
  162    if ((*cfg_iface_ != *other.cfg_iface_) ||
 
  163        (*cfg_option_def_ != *other.cfg_option_def_) ||
 
  164        (*cfg_option_ != *other.cfg_option_) ||
 
  165        (*class_dictionary_ != *other.class_dictionary_) ||
 
  166        (*d2_client_config_ != *other.d2_client_config_)) {
 
  172    if (hooks_config_.get().size() != other.hooks_config_.
get().size()) {
 
  177    return (hooks_config_.equal(other.hooks_config_));
 
 
  189        mergeGlobals(other_srv_config);
 
  192        mergeGlobalContainers(other_srv_config);
 
  201        cfg_option_->merge(cfg_option_def_, *other_srv_config.
getCfgOption());
 
  213            merge4(other_srv_config);
 
  215            merge6(other_srv_config);
 
  217    } 
catch (
const std::bad_cast&) {
 
  219                  " of the SrvConfig as an argument of the call to" 
  220                  " SrvConfig::merge()");
 
 
  237SrvConfig::merge6(SrvConfig& other) {
 
  239    cfg_shared_networks6_->merge(cfg_option_def_, *(other.getCfgSharedNetworks6()));
 
  243                         *(other.getCfgSubnets6()));
 
  249SrvConfig::mergeGlobals(SrvConfig& other) {
 
  253    for (
auto const& other_global : other.getConfiguredGlobals()->valuesMap()) {
 
  260        std::string name = merged_global.first;
 
  263            if (name == 
"decline-probation-period") {
 
  265            } 
else if (name == 
"echo-client-id") {
 
  269            } 
else if (name == 
"dhcp4o6-port") {
 
  271            } 
else if (name == 
"server-tag") {
 
  273            } 
else if (name == 
"ip-reservations-unique") {
 
  275            } 
else if (name == 
"reservations-lookup-first") {
 
  278        } 
catch(
const std::exception& ex) {
 
  279            isc_throw (BadValue, 
"Invalid value:" << element->str()
 
  280                       << 
" explicit global:" << name);
 
  286SrvConfig::mergeGlobalContainers(
SrvConfig& other) {
 
  288    for (
auto const& other_global : other.getConfiguredGlobals()->valuesMap()) {
 
  289        config->set(other_global.first, other_global.second);
 
  291    std::string parameter_name;
 
  294        ConstElementPtr host_reservation_identifiers = config->get(
"host-reservation-identifiers");
 
  295        parameter_name = 
"host-reservation-identifiers";
 
  296        if (host_reservation_identifiers) {
 
  299                parser.parse(host_reservation_identifiers);
 
  302                parser.parse(host_reservation_identifiers);
 
  308        parameter_name = 
"compatibility";
 
  310            CompatibilityParser parser;
 
  311            parser.parse(compatibility, *
this);
 
  314        ElementPtr dhcp_ddns = boost::const_pointer_cast<Element>(config->get(
"dhcp-ddns"));
 
  315        parameter_name = 
"dhcp-ddns";
 
  319            D2ClientConfigParser parser;
 
  322            d2_client_cfg = parser.parse(dhcp_ddns);
 
  323            if (!d2_client_cfg) {
 
  324                d2_client_cfg.reset(
new D2ClientConfig());
 
  326            d2_client_cfg->validateContents();
 
  330        ConstElementPtr expiration_cfg = config->get(
"expired-leases-processing");
 
  331        parameter_name = 
"expired-leases-processing";
 
  332        if (expiration_cfg) {
 
  333            ExpirationConfigParser parser;
 
  337        ElementPtr multi_threading = boost::const_pointer_cast<Element>(config->get(
"multi-threading"));
 
  338        parameter_name = 
"multi-threading";
 
  339        if (multi_threading) {
 
  345            MultiThreadingConfigParser parser;
 
  346            parser.parse(*
this, multi_threading);
 
  349        bool multi_threading_enabled = 
true;
 
  350        uint32_t thread_count = 0;
 
  351        uint32_t queue_size = 0;
 
  353                                   multi_threading_enabled, thread_count, queue_size);
 
  354        ElementPtr sanity_checks = boost::const_pointer_cast<Element>(config->get(
"sanity-checks"));
 
  355        parameter_name = 
"sanity-checks";
 
  362            SanityChecksParser parser;
 
  363            parser.parse(*
this, sanity_checks);
 
  367        parameter_name = 
"server-id";
 
  369            DUIDConfigParser parser;
 
  371            parser.parse(cfg, server_id);
 
  374        ElementPtr queue_control = boost::const_pointer_cast<Element>(config->get(
"dhcp-queue-control"));
 
  375        parameter_name = 
"dhcp-queue-control";
 
  382            DHCPQueueControlParser parser;
 
  386    } 
catch (
const isc::Exception& ex) {
 
  387        isc_throw(BadValue, 
"Invalid parameter " << parameter_name << 
" error: " << ex.
what());
 
  389        isc_throw(BadValue, 
"Invalid parameter " << parameter_name);
 
  406    uint32_t max_samples = 0;
 
  408        max_samples = samples->intValue();
 
  410        if (max_samples != 0) {
 
  417        int64_t time_duration = duration->intValue();
 
  418        auto max_age = std::chrono::seconds(time_duration);
 
  420        if (max_samples == 0) {
 
 
  446    for (
auto const& def_value : defaults) {
 
  458        switch (def_value.type_) {
 
  465                int int_value = boost::lexical_cast<int>(def_value.value_);
 
  468            catch (
const std::exception& ex) {
 
  470                          "Internal error. Integer value expected for: " 
  471                          << def_value.name_ << 
", value is: " 
  472                          << def_value.value_ );
 
  479            if (def_value.value_ == std::string(
"true")) {
 
  481            } 
else if (def_value.value_ == std::string(
"false")) {
 
  485                          "Internal error. Boolean value for " 
  486                          << def_value.name_ << 
" specified as " 
  487                          << def_value.value_ << 
", expected true or false");
 
  493            double dbl_value = boost::lexical_cast<double>(def_value.value_);
 
  500                      "Internal error. Incorrect default value type for " 
 
  513    const std::map<std::string, ConstElementPtr>& values = 
config->mapValue();
 
  514    for (
auto const& value : values) {
 
 
  528        value = has_value->intValue();
 
  531    uint32_t min_value = 0;
 
  534        min_value = has_min->intValue();
 
  537    uint32_t max_value = 0;
 
  540        max_value = has_max->intValue();
 
  543    if (!has_value && !has_min && !has_max) {
 
  547        if (!has_min && !has_max) {
 
  550        } 
else if (!has_min) {
 
  553        } 
else if (!has_max) {
 
  557    } 
else if (has_min) {
 
  564                      << name << 
" but no " << name << 
" (default)");
 
  572    if (min_value > max_value) {
 
  573        if (has_min && has_max) {
 
  575                      << min_value << 
") is not less than max-" << name << 
" (" 
  576                      << max_value << 
")");
 
  577        } 
else if (has_min) {
 
  580                      << min_value << 
") is not less than (default) " << name
 
  581                      << 
" (" << value << 
")");
 
  585                      << 
" (" << value << 
") is not less than max-" << name
 
  586                      << 
" (" << max_value << 
")");
 
  591    if ((value < min_value) || (value > max_value)) {
 
  593                  << value << 
") is not between min-" << name << 
" (" 
  594                  << min_value << 
") and max-" << name << 
" (" 
  595                  << max_value << 
")");
 
 
  601                                const std::string& name)
 const {
 
  608    bool new_value = 
true;
 
  614        value = has_value->intValue();
 
  617    uint32_t min_value = 0;
 
  625        min_value = has_min->intValue();
 
  628    uint32_t max_value = 0;
 
  636        max_value = has_max->intValue();
 
  639    if (!has_value && !has_min && !has_max) {
 
  643        if (!has_min && !has_max) {
 
  646        } 
else if (!has_min) {
 
  649        } 
else if (!has_max) {
 
  653    } 
else if (has_min) {
 
  660                      << name << 
" but no " << name << 
" (default)");
 
  668    if (min_value > max_value) {
 
  669        if (has_min && has_max) {
 
  670            std::string from_min = (new_min ? 
"new" : 
"previous");
 
  671            std::string from_max = (new_max ? 
"new" : 
"previous");
 
  673                      << 
" min-" << name << 
" (" 
  674                      << min_value << 
") is not less than " 
  675                      << from_max << 
" max-" << name
 
  676                      << 
" (" << max_value << 
")");
 
  677        } 
else if (has_min) {
 
  679            std::string from_min = (new_min ? 
"new" : 
"previous");
 
  680            std::string from_value = (new_value ? 
"new" : 
"previous");
 
  682                      << 
" min-" << name << 
" (" 
  683                      << min_value << 
") is not less than " << from_value
 
  684                      << 
" (default) " << name
 
  685                      << 
" (" << value << 
")");
 
  688            std::string from_max = (new_max ? 
"new" : 
"previous");
 
  689            std::string from_value = (new_value ? 
"new" : 
"previous");
 
  691                      << 
" (default) " << name
 
  692                      << 
" (" << value << 
") is not less than " << from_max
 
  693                      << 
" max-" << name << 
" (" << max_value << 
")");
 
  698    if ((value < min_value) || (value > max_value)) {
 
  699        std::string from_value = (new_value ? 
"new" : 
"previous");
 
  700        std::string from_min = (new_min ? 
"new" : 
"previous");
 
  701        std::string from_max = (new_max ? 
"new" : 
"previous");
 
  703                  <<
" (default) " << name << 
" (" 
  704                  << value << 
") is not between " << from_min
 
  705                  << 
" min-" << name << 
" (" << min_value
 
  706                  << 
") and " << from_max << 
" max-" 
  707                  << name << 
" (" << max_value << 
")");
 
 
  724    if (!loggers_info.empty()) {
 
  727        for (LoggingInfoStorage::const_iterator logger =
 
  728                loggers_info.cbegin();
 
  729             logger != loggers_info.cend(); ++logger) {
 
  730            loggers->add(logger->toElement());
 
  732        dhcp->set(
"loggers", loggers);
 
  744        compatibility->set(
"ignore-dhcp-server-identifier", 
Element::create(
true));
 
  747        compatibility->set(
"ignore-rai-link-selection", 
Element::create(
true));
 
  752    if (compatibility->size() > 0) {
 
  753        dhcp->set(
"compatibility", compatibility);
 
  757    dhcp->set(
"decline-probation-period",
 
  760    if (family == AF_INET) {
 
  764    dhcp->set(
"dhcp4o6-port",
 
  767    dhcp->set(
"dhcp-ddns", d2_client_config_->toElement());
 
  769    dhcp->set(
"interfaces-config", cfg_iface_->toElement());
 
  771    dhcp->set(
"option-def", cfg_option_def_->toElement());
 
  773    dhcp->set(
"option-data", cfg_option_->toElement());
 
  786    std::vector<ElementPtr> sn_list;
 
  788    if (family == AF_INET) {
 
  792        for (
auto const& subnet : *subnets) {
 
  795            subnet->getSharedNetwork(network);
 
  800            sn_list.push_back(subnet_cfg);
 
  801            plain_subnets->add(subnet_cfg);
 
  803        dhcp->set(
"subnet4", plain_subnets);
 
  806        ElementPtr shared_networks = cfg_shared_networks4_->toElement();
 
  807        dhcp->set(
"shared-networks", shared_networks);
 
  810        const std::vector<ElementPtr> networks = shared_networks->listValue();
 
  811        for (
auto const& network : networks) {
 
  812            const std::vector<ElementPtr> sh_list =
 
  813                network->get(
"subnet4")->listValue();
 
  814            for (
auto const& subnet : sh_list) {
 
  815                sn_list.push_back(subnet);
 
  823        for (
auto const& subnet : *subnets) {
 
  826            subnet->getSharedNetwork(network);
 
  831            sn_list.push_back(subnet_cfg);
 
  832            plain_subnets->add(subnet_cfg);
 
  834        dhcp->set(
"subnet6", plain_subnets);
 
  837        ElementPtr shared_networks = cfg_shared_networks6_->toElement();
 
  838        dhcp->set(
"shared-networks", shared_networks);
 
  841        const std::vector<ElementPtr> networks = shared_networks->listValue();
 
  842        for (
auto const& network : networks) {
 
  843            const std::vector<ElementPtr> sh_list =
 
  844                network->get(
"subnet6")->listValue();
 
  845            for (
auto const& subnet : sh_list) {
 
  846                sn_list.push_back(subnet);
 
  857    if (global_resvs->size() > 0) {
 
  858        dhcp->set(
"reservations", global_resvs);
 
  862    for (
auto const& subnet : sn_list) {
 
  867        SubnetID subnet_id = 
id->intValue();
 
  869        subnet->set(
"reservations", resvs);
 
  874    dhcp->set(
"expired-leases-processing", expired);
 
  875    if (family == AF_INET6) {
 
  877        dhcp->set(
"server-id", cfg_duid_->toElement());
 
  880        dhcp->set(
"relay-supplied-options", cfg_rsoo_->toElement());
 
  888    if (hosts_databases->size() > 0) {
 
  889        dhcp->set(
"hosts-databases", hosts_databases);
 
  893    if (family == AF_INET) {
 
  894        host_ids = cfg_host_operations4_->toElement();
 
  896        host_ids = cfg_host_operations6_->toElement();
 
  898    dhcp->set(
"host-reservation-identifiers", host_ids);
 
  900    if (family == AF_INET6) {
 
  901        dhcp->set(
"mac-sources", cfg_mac_source_.toElement());
 
  905    if (!
isNull(unix_control_socket_)) {
 
  906        for (
auto const& socket : unix_control_socket_->listValue()) {
 
  910    if (!
isNull(http_control_socket_)) {
 
  911        for (
auto const& socket : http_control_socket_->listValue()) {
 
  915    if (!control_sockets->empty()) {
 
  916        dhcp->set(
"control-sockets", control_sockets);
 
  921    if (!client_classes->empty()) {
 
  922        dhcp->set(
"client-classes", client_classes);
 
  926    dhcp->set(
"hooks-libraries", hooks_libs);
 
  928    result->set(family == AF_INET ? 
"Dhcp4" : 
"Dhcp6", 
dhcp);
 
  931    dhcp->set(
"sanity-checks", cfg_consist);
 
  937        dhcp->set(
"config-control", info_elem);
 
  942    if (dhcp_queue_control) {
 
  943        dhcp->set(
"dhcp-queue-control", dhcp_queue_control);
 
  948    if (dhcp_multi_threading) {
 
  949        dhcp->set(
"multi-threading", dhcp_multi_threading);
 
 
  988        auto optional = pool_->getDdnsSendUpdates();
 
  989        if (!optional.unspecified()) {
 
  990            return (optional.get());
 
  994    return (d2_client_enabled_ && subnet_->getDdnsSendUpdates().get());
 
 
 1004        auto optional = pool_->getDdnsOverrideNoUpdate();
 
 1005        if (!optional.unspecified()) {
 
 1006            return (optional.get());
 
 1010    return (subnet_->getDdnsOverrideNoUpdate().get());
 
 
 1019        auto optional = pool_->getDdnsOverrideClientUpdate();
 
 1020        if (!optional.unspecified()) {
 
 1021            return (optional.get());
 
 1025    return (subnet_->getDdnsOverrideClientUpdate().get());
 
 
 1035        auto optional = pool_->getDdnsReplaceClientNameMode();
 
 1036        if (!optional.unspecified()) {
 
 1037            return (optional.get());
 
 1041    return (subnet_->getDdnsReplaceClientNameMode().get());
 
 
 1051        auto optional = pool_->getDdnsGeneratedPrefix();
 
 1052        if (!optional.unspecified()) {
 
 1053            return (optional.get());
 
 1057    return (subnet_->getDdnsGeneratedPrefix().get());
 
 
 1067        auto optional = pool_->getDdnsQualifyingSuffix();
 
 1068        if (!optional.unspecified()) {
 
 1069            return (optional.get());
 
 1073    return (subnet_->getDdnsQualifyingSuffix().get());
 
 
 1082    return (subnet_->getHostnameCharSet().get());
 
 
 1091    return (subnet_->getHostnameCharReplacement().get());
 
 
 1099        if (!char_set.empty()) {
 
 1103            } 
catch (
const std::exception& ex) {
 
 1105                                    "' is not a valid regular expression");
 
 
 1127    if (has_ddns_ttl_min && has_ddns_ttl) {
 
 1132    if (has_ddns_ttl_max) {
 
 1137        if (has_ddns_ttl_min) {
 
 1139            uint32_t ddns_ttl_min = has_ddns_ttl_min->intValue();
 
 1140            uint32_t ddns_ttl_max = has_ddns_ttl_max->intValue();
 
 1141            if (ddns_ttl_max < ddns_ttl_min) {
 
 1143                          << 
" must be greater than ddns-ttl-min: " <<  ddns_ttl_min);
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown if a function is called in a prohibited way.
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
Notes: IntElement type is changed to int64_t.
static size_t setDefaults(isc::data::ElementPtr scope, const SimpleDefaults &default_values)
Sets the default values.
Parameters for various consistency checks.
Holds manual configuration of the server identifier (DUID).
Holds access parameters and the configuration of the lease and hosts database connection.
Holds configuration parameters pertaining to lease expiration and lease affinity.
Class to store configured global parameters.
Represents global configuration for host reservations.
Utility class to represent host reservation configurations internally as a map keyed by subnet IDs,...
isc::data::ConstElementPtr get(SubnetID id) const
Return the host reservations for a subnet ID.
void internalize(isc::data::ConstElementPtr list)
Internalize a list Element.
Represents the host reservations specified in the configuration file.
Represents selection of interfaces for DHCP server.
uint16_t getFamily() const
Returns address family.
static CfgMgr & instance()
returns a single instance of Configuration Manager
static void extract(data::ConstElementPtr value, bool &enabled, uint32_t &thread_count, uint32_t &queue_size)
Extract multi-threading parameters from a given configuration.
Represents option definitions used by the DHCP server.
Represents option data configuration for the DHCP server.
Represents configuration of the RSOO options for the DHCP server.
Represents configuration of IPv4 shared networks.
Represents configuration of IPv6 shared networks.
Holds subnets configured for the DHCPv4 server.
Holds subnets configured for the DHCPv6 server.
Maintains a list of ClientClassDef's.
static size_t setAllDefaults(isc::data::ConstElementPtr d2_config)
Sets all defaults for D2 client configuration.
Acts as a storage vault for D2 client configuration.
ReplaceClientNameMode
Defines the client name replacement modes.
Convenience container for conveying DDNS behavioral parameters It is intended to be created per Packe...
std::string getHostnameCharReplacement() const
Returns the string to replace invalid characters when scrubbing hostnames.
D2ClientConfig::ReplaceClientNameMode getReplaceClientNameMode() const
Returns how Kea should handle the domain-name supplied by the client.
std::string getGeneratedPrefix() const
Returns the Prefix Kea should use when generating domain-names.
isc::util::str::StringSanitizerPtr getHostnameSanitizer() const
Returns a regular expression string sanitizer.
std::string getHostnameCharSet() const
Returns the regular expression describing invalid characters for client hostnames.
std::string getQualifyingSuffix() const
Returns the suffix Kea should use when to qualify partial domain-names.
bool getOverrideNoUpdate() const
Returns whether or not Kea should perform updates, even if client requested no updates.
bool getEnableUpdates() const
Returns whether or not DHCP DDNS updating is enabled.
bool getOverrideClientUpdate() const
Returns whether or not Kea should perform updates, even if client requested delegation.
static bool haveInstance()
Indicates if the lease manager has been instantiated.
static bool lenient_parsing_
Governs whether options should be parsed less strictly.
static const isc::data::SimpleDefaults DHCP_MULTI_THREADING4_DEFAULTS
This table defines default values for multi-threading in DHCPv4.
static const isc::data::SimpleDefaults SANITY_CHECKS4_DEFAULTS
This defines default values for sanity checking for DHCPv4.
static const isc::data::SimpleDefaults DHCP_QUEUE_CONTROL4_DEFAULTS
This table defines default values for dhcp-queue-control in DHCPv4.
static const isc::data::SimpleDefaults DHCP_QUEUE_CONTROL6_DEFAULTS
This table defines default values for dhcp-queue-control in DHCPv6.
static const isc::data::SimpleDefaults DHCP_MULTI_THREADING6_DEFAULTS
This table defines default values for multi-threading in DHCPv6.
static const isc::data::SimpleDefaults SANITY_CHECKS6_DEFAULTS
This defines default values for sanity checking for DHCPv6.
Specifies current DHCP configuration.
ClientClassDictionaryPtr getClientClassDictionary()
Returns pointer to the dictionary of global client class definitions.
static const uint32_t CFGSEL_SUBNET4
Number of IPv4 subnets.
void setDhcp4o6Port(uint16_t port)
Sets DHCP4o6 IPC port.
void addConfiguredGlobal(const std::string &name, isc::data::ConstElementPtr value)
Adds a parameter to the collection configured globals.
CfgGlobalsPtr getConfiguredGlobals()
Returns non-const pointer to configured global parameters.
void sanityChecksDdnsTtlParameters() const
Conducts sanity checks on global DDNS ttl parameters: ddns-ttl, ddns-ttl-percent, ddns-ttl-min,...
void setClientClassDictionary(const ClientClassDictionaryPtr &dictionary)
Sets the client class dictionary.
virtual void merge(ConfigBase &other)
Merges the configuration specified as a parameter into this configuration.
void extractConfiguredGlobals(isc::data::ConstElementPtr config)
Saves scalar elements from the global scope of a configuration.
isc::data::ConstElementPtr getConfiguredGlobal(std::string name) const
Returns pointer to a given configured global parameter.
CfgSharedNetworks6Ptr getCfgSharedNetworks6() const
Returns pointer to non-const object holding configuration of shared networks in DHCPv6.
bool getIgnoreRAILinkSelection() const
Get ignore RAI Link Selection compatibility flag.
void setD2ClientConfig(const D2ClientConfigPtr &d2_client_config)
Sets the D2 client configuration.
void applyDefaultsConfiguredGlobals(const isc::data::SimpleDefaults &defaults)
Applies defaults to global parameters.
void setIPReservationsUnique(const bool unique)
Configures the server to allow or disallow specifying multiple hosts with the same IP address/subnet.
void configureLowerLevelLibraries() const
Convenience method to propagate configuration parameters through inversion of control.
CfgDUIDPtr getCfgDUID()
Returns pointer to the object holding configuration of the server identifier.
bool sequenceEquals(const SrvConfig &other)
Compares configuration sequence with other sequence.
CfgSubnets4Ptr getCfgSubnets4()
Returns pointer to non-const object holding subnets configuration for DHCPv4.
CfgSubnets6Ptr getCfgSubnets6()
Returns pointer to non-const object holding subnets configuration for DHCPv6.
CfgOptionDefPtr getCfgOptionDef()
Return pointer to non-const object representing user-defined option definitions.
D2ClientConfigPtr getD2ClientConfig()
Returns pointer to the D2 client configuration.
CfgHostOperationsPtr getCfgHostOperations6()
Returns pointer to the object holding general configuration for host reservations in DHCPv6.
void setReservationsLookupFirst(const bool first)
Sets whether the server does host reservations lookup before lease lookup.
const isc::data::ConstElementPtr getDHCPMultiThreading() const
Returns DHCP multi threading information.
void setDHCPQueueControl(const isc::data::ConstElementPtr dhcp_queue_control)
Sets information about the dhcp queue control.
DdnsParamsPtr getDdnsParams(const ConstSubnet4Ptr &subnet) const
Fetches the DDNS parameters for a given DHCPv4 subnet.
void sanityChecksLifetime(const std::string &name) const
Conducts sanity checks on global lifetime parameters.
std::string getConfigSummary(const uint32_t selection) const
Returns summary of the configuration in the textual format.
const isc::data::ConstElementPtr getDHCPQueueControl() const
Returns DHCP queue control information.
bool equals(const SrvConfig &other) const
Compares two objects for equality.
uint32_t getSequence() const
Returns configuration sequence number.
static const uint32_t CFGSEL_DDNS
DDNS enabled/disabled.
void setDeclinePeriod(const uint32_t decline_timer)
Sets decline probation-period.
void removeStatistics()
Removes statistics.
CfgExpirationPtr getCfgExpiration()
Returns pointer to the object holding configuration pertaining to processing expired leases.
CfgOptionPtr getCfgOption()
Returns pointer to the non-const object holding options.
virtual isc::data::ElementPtr toElement() const
Unparse a configuration object.
bool getLenientOptionParsing() const
Get lenient option parsing compatibility flag.
static const uint32_t CFGSEL_SUBNET6
Number of IPv6 subnets.
bool getExcludeFirstLast24() const
Get exclude .0 and .255 addresses in subnets bigger than /24 flag.
void updateStatistics()
Updates statistics.
CfgDbAccessPtr getCfgDbAccess()
Returns pointer to the object holding configuration of the lease and host database connection paramet...
void setEchoClientId(const bool echo)
Sets whether server should send back client-id in DHCPv4.
void copy(SrvConfig &new_config) const
Copies the current configuration to a new configuration.
CfgSharedNetworks4Ptr getCfgSharedNetworks4() const
Returns pointer to non-const object holding configuration of shared networks in DHCPv4;.
CfgHostsPtr getCfgHosts()
Returns pointer to the non-const objects representing host reservations for different IPv4 and IPv6 s...
bool getIgnoreServerIdentifier() const
Get ignore DHCP Server Identifier compatibility flag.
SrvConfig()
Default constructor.
CfgHostOperationsPtr getCfgHostOperations4()
Returns pointer to the object holding general configuration for host reservations in DHCPv4.
void clear()
Removes all configured hooks libraries.
void add(const std::string &libname, isc::data::ConstElementPtr parameters, const std::string &cfgname="")
Adds additional hooks libraries.
const isc::hooks::HookLibsCollection & get() const
Provides access to the configured hooks libraries.
Base class for all configurations.
process::ConstConfigControlInfoPtr getConfigControlInfo() const
Fetches a read-only copy of the configuration control information.
const process::LoggingInfoStorage & getLoggingInfo() const
Returns logging specific configuration.
void setServerTag(const util::Optional< std::string > &server_tag)
Sets the server's logical name.
void copy(ConfigBase &new_config) const
Copies the current configuration to a new configuration.
virtual void merge(ConfigBase &other)
Merges specified configuration into this configuration.
bool equals(const ConfigBase &other) const
Compares two configuration.
Statistics Manager class.
static StatsMgr & instance()
Statistics Manager accessor method.
Implements a regular expression based string scrubber.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
void setMaxSampleCountDefault(uint32_t max_samples)
Set default count limit.
void setMaxSampleAgeAll(const StatsDuration &duration)
Set duration limit for all collected statistics.
void setMaxSampleCountAll(uint32_t max_samples)
Set count limit for all collected statistics.
void setMaxSampleAgeDefault(const StatsDuration &duration)
Set default duration limit.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
boost::shared_ptr< const Element > ConstElementPtr
bool isNull(ConstElementPtr p)
Checks whether the given ElementPtr is a NULL pointer.
std::vector< SimpleDefault > SimpleDefaults
This specifies all default values in a given scope (e.g. a subnet).
boost::shared_ptr< Element > ElementPtr
isc::log::Logger dhcpsrv_logger("dhcpsrv")
DHCP server library Logger.
boost::shared_ptr< CfgDUID > CfgDUIDPtr
Pointer to the Non-const object.
boost::shared_ptr< D2ClientConfig > D2ClientConfigPtr
Defines a pointer for D2ClientConfig instances.
boost::shared_ptr< const Subnet6 > ConstSubnet6Ptr
A const pointer to a Subnet6 object.
boost::shared_ptr< const Subnet4 > ConstSubnet4Ptr
A const pointer to a Subnet4 object.
boost::multi_index_container< Subnet6Ptr, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetSubnetIdIndexTag >, boost::multi_index::const_mem_fun< Subnet, SubnetID, &Subnet::getID > >, boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetPrefixIndexTag >, boost::multi_index::const_mem_fun< Subnet, std::string, &Subnet::toText > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SubnetModificationTimeIndexTag >, boost::multi_index::const_mem_fun< data::BaseStampedElement, boost::posix_time::ptime, &data::BaseStampedElement::getModificationTime > > > > Subnet6Collection
A collection of Subnet6 objects.
boost::shared_ptr< DdnsParams > DdnsParamsPtr
Defines a pointer for DdnsParams instances.
boost::shared_ptr< SharedNetwork6 > SharedNetwork6Ptr
Pointer to SharedNetwork6 object.
boost::multi_index_container< Subnet4Ptr, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetSubnetIdIndexTag >, boost::multi_index::const_mem_fun< Subnet, SubnetID, &Subnet::getID > >, boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetPrefixIndexTag >, boost::multi_index::const_mem_fun< Subnet, std::string, &Subnet::toText > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SubnetServerIdIndexTag >, boost::multi_index::const_mem_fun< Network4, asiolink::IOAddress, &Network4::getServerId > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SubnetModificationTimeIndexTag >, boost::multi_index::const_mem_fun< data::BaseStampedElement, boost::posix_time::ptime, &data::BaseStampedElement::getModificationTime > > > > Subnet4Collection
A collection of Subnet4 objects.
uint32_t SubnetID
Defines unique IPv4 or IPv6 subnet identifier.
const isc::log::MessageID DHCPSRV_CFGMGR_IP_RESERVATIONS_UNIQUE_DUPLICATES_POSSIBLE
boost::shared_ptr< SharedNetwork4 > SharedNetwork4Ptr
Pointer to SharedNetwork4 object.
boost::shared_ptr< const ConfigControlInfo > ConstConfigControlInfoPtr
Defines a pointer to a const ConfigControlInfo.
std::unique_ptr< StringSanitizer > StringSanitizerPtr
Type representing the pointer to the StringSanitizer.
Defines the logger used by the top-level component of kea-lfc.
Represents the position of the data element within a configuration string.
void contextToElement(data::ElementPtr map) const
Merge unparse a user_context object.
static data::ElementPtr toElement(data::ConstElementPtr map)
Copy an Element map.
virtual isc::data::ElementPtr toElement() const
Unparse.
utility class for unparsing
virtual isc::data::ElementPtr toElement() const
Unparse.