52#include <boost/algorithm/string.hpp> 
   53#include <boost/lexical_cast.hpp> 
   59#include <netinet/in.h> 
  107        bool echo_client_id = getBoolean(global, 
"echo-client-id");
 
  108        cfg->setEchoClientId(echo_client_id);
 
  111        uint32_t probation_period =
 
  112            getUint32(global, 
"decline-probation-period");
 
  113        cfg->setDeclinePeriod(probation_period);
 
  116        uint16_t dhcp4o6_port = getUint16(global, 
"dhcp4o6-port");
 
  117        cfg->setDhcp4o6Port(dhcp4o6_port);
 
  122            cfg->setContext(user_context);
 
  126        std::string server_tag = getString(global, 
"server-tag");
 
  127        cfg->setServerTag(server_tag);
 
  143        bool ip_reservations_unique = getBoolean(global, 
"ip-reservations-unique");
 
  144        cfg->setIPReservationsUnique(ip_reservations_unique);
 
  156        if (!dest || !from) {
 
  157            isc_throw(BadValue, 
"Unable to copy subnets: at least one pointer is null");
 
  168        for (
auto const& net : *networks) {
 
  179            for (
auto const& subnet : *subnets) {
 
  197        cfg->sanityChecksLifetime(
"valid-lifetime");
 
  200        cfg->sanityChecksDdnsTtlParameters();
 
  205            sharedNetworksSanityChecks(*networks, global->get(
"shared-networks"));
 
  227        std::set<string> names;
 
  230        for (
auto const& net : networks) {
 
  235            bool authoritative = net->getAuthoritative();
 
  236            string iface = net->getIface();
 
  241                for (
auto const& subnet : *subnets) {
 
  242                    if (subnet->getAuthoritative() != authoritative) {
 
  243                        isc_throw(DhcpConfigError, 
"Subnet " << boolalpha
 
  245                                  << 
" has different authoritative setting " 
  246                                  << subnet->getAuthoritative()
 
  247                                  << 
" than the shared-network itself: " 
  252                        iface = subnet->getIface();
 
  256                    if (subnet->getIface().empty()) {
 
  260                    if (subnet->getIface() != iface) {
 
  261                        isc_throw(DhcpConfigError, 
"Subnet " << subnet->toText()
 
  262                                  << 
" has specified interface " << subnet->getIface()
 
  263                                  << 
", but earlier subnet in the same shared-network" 
  264                                  << 
" or the shared-network itself used " << iface);
 
  269                    txt += subnet->toText() + 
" ";
 
  274            if (net->getName().empty()) {
 
  275                isc_throw(DhcpConfigError, 
"Shared-network with subnets " 
  276                          << txt << 
" is missing mandatory 'name' parameter");
 
  280            if (names.find(net->getName()) != names.end()) {
 
  281                isc_throw(DhcpConfigError, 
"A shared-network with " 
  282                          "name " << net->getName() << 
" defined twice.");
 
  284            names.insert(net->getName());
 
  314    bool sock_changed = (unix_config && current_unix_config &&
 
  315                         !unix_config->equals(*current_unix_config));
 
  322    if (!unix_config || !current_unix_config || sock_changed) {
 
  329        } 
else if (current_unix_config) {
 
  344    } 
else if (current_http_config) {
 
 
  365    string parameter_name;
 
  375        mutable_cfg = boost::const_pointer_cast<Element>(config_set);
 
  390        Dhcp4ConfigParser global_parser;
 
  393        global_parser.parseEarly(srv_config, mutable_cfg);
 
  398            parameter_name = 
"option-def";
 
  401            parser.
parse(cfg_option_def, option_defs);
 
  406            parameter_name = 
"option-data";
 
  409            parser.
parse(cfg_option, option_datas);
 
  413        if (control_socket) {
 
  414            mutable_cfg->remove(
"control-socket");
 
  417            mutable_cfg->set(
"control-sockets", l);
 
  421        if (control_sockets) {
 
  422            parameter_name = 
"control-sockets";
 
  424            parser.
parse(*srv_config, control_sockets);
 
  428        if (multi_threading) {
 
  429            parameter_name = 
"multi-threading";
 
  431            parser.
parse(*srv_config, multi_threading);
 
  434        bool multi_threading_enabled = 
true;
 
  435        uint32_t thread_count = 0;
 
  436        uint32_t queue_size = 0;
 
  438                                   multi_threading_enabled, thread_count, queue_size);
 
  441        ConstElementPtr queue_control = mutable_cfg->get(
"dhcp-queue-control");
 
  443            parameter_name = 
"dhcp-queue-control";
 
  445            srv_config->setDHCPQueueControl(parser.
parse(queue_control, multi_threading_enabled));
 
  449        ConstElementPtr reservations_lookup_first = mutable_cfg->get(
"reservations-lookup-first");
 
  450        if (reservations_lookup_first) {
 
  451            parameter_name = 
"reservations-lookup-first";
 
  452            if (multi_threading_enabled) {
 
  455            srv_config->setReservationsLookupFirst(reservations_lookup_first->boolValue());
 
  459            mutable_cfg->get(
"host-reservation-identifiers");
 
  460        if (hr_identifiers) {
 
  461            parameter_name = 
"host-reservation-identifiers";
 
  463            parser.
parse(hr_identifiers);
 
  468            parameter_name = 
"sanity-checks";
 
  470            parser.
parse(*srv_config, sanity_checks);
 
  474            mutable_cfg->get(
"expired-leases-processing");
 
  475        if (expiration_cfg) {
 
  476            parameter_name = 
"expired-leases-processing";
 
  485        if (hooks_libraries) {
 
  486            parameter_name = 
"hooks-libraries";
 
  488            HooksConfig& libraries = srv_config->getHooksConfig();
 
  489            hooks_parser.
parse(libraries, hooks_libraries);
 
  491                                      multi_threading_enabled);
 
  500            parameter_name = 
"dhcp-ddns";
 
  508        if (client_classes) {
 
  509            parameter_name = 
"client-classes";
 
  512                parser.
parse(client_classes, AF_INET);
 
  513            srv_config->setClientClassDictionary(dictionary);
 
  518        if (lease_database) {
 
  519            parameter_name = 
"lease-database";
 
  521            std::string access_string;
 
  522            parser.
parse(access_string, lease_database);
 
  524            cfg_db_access->setLeaseDbAccessString(access_string);
 
  528        if (hosts_database) {
 
  529            parameter_name = 
"hosts-database";
 
  531            std::string access_string;
 
  532            parser.
parse(access_string, hosts_database);
 
  534            cfg_db_access->setHostDbAccessString(access_string);
 
  538        if (hosts_databases) {
 
  539            parameter_name = 
"hosts-databases";
 
  541            for (
auto const& it : hosts_databases->listValue()) {
 
  543                std::string access_string;
 
  544                parser.
parse(access_string, it);
 
  545                cfg_db_access->setHostDbAccessString(access_string);
 
  551        if (shared_networks) {
 
  552            parameter_name = 
"shared-networks";
 
  560            parser.
parse(cfg, shared_networks);
 
  564            global_parser.copySubnets4(srv_config->getCfgSubnets4(), cfg);
 
  569            parameter_name = 
"subnet4";
 
  572            subnets_parser.
parse(srv_config, subnet4);
 
  577            parameter_name = 
"reservations";
 
  580            parser.
parse(SUBNET_ID_GLOBAL, reservations, hosts);
 
  581            for (
auto const& h : hosts) {
 
  582                srv_config->getCfgHosts()->add(h);
 
  587        if (config_control) {
 
  588            parameter_name = 
"config-control";
 
  601        const std::map<std::string, ConstElementPtr>& values_map =
 
  602            mutable_cfg->mapValue();
 
  604        for (
auto const& config_pair : values_map) {
 
  605            parameter_name = config_pair.first;
 
  608            if ((config_pair.first == 
"option-def") ||
 
  609                (config_pair.first == 
"option-data") ||
 
  610                (config_pair.first == 
"control-socket") ||
 
  611                (config_pair.first == 
"control-sockets") ||
 
  612                (config_pair.first == 
"multi-threading") ||
 
  613                (config_pair.first == 
"dhcp-queue-control") ||
 
  614                (config_pair.first == 
"host-reservation-identifiers") ||
 
  615                (config_pair.first == 
"interfaces-config") ||
 
  616                (config_pair.first == 
"sanity-checks") ||
 
  617                (config_pair.first == 
"expired-leases-processing") ||
 
  618                (config_pair.first == 
"hooks-libraries") ||
 
  619                (config_pair.first == 
"dhcp-ddns") ||
 
  620                (config_pair.first == 
"client-classes") ||
 
  621                (config_pair.first == 
"lease-database") ||
 
  622                (config_pair.first == 
"hosts-database") ||
 
  623                (config_pair.first == 
"hosts-databases") ||
 
  624                (config_pair.first == 
"subnet4") ||
 
  625                (config_pair.first == 
"shared-networks") ||
 
  626                (config_pair.first == 
"reservations") ||
 
  627                (config_pair.first == 
"config-control") ||
 
  628                (config_pair.first == 
"loggers") ||
 
  629                (config_pair.first == 
"compatibility")) {
 
  643            if ( (config_pair.first == 
"renew-timer") ||
 
  644                 (config_pair.first == 
"rebind-timer") ||
 
  645                 (config_pair.first == 
"valid-lifetime") ||
 
  646                 (config_pair.first == 
"min-valid-lifetime") ||
 
  647                 (config_pair.first == 
"max-valid-lifetime") ||
 
  648                 (config_pair.first == 
"decline-probation-period") ||
 
  649                 (config_pair.first == 
"dhcp4o6-port") ||
 
  650                 (config_pair.first == 
"echo-client-id") ||
 
  651                 (config_pair.first == 
"match-client-id") ||
 
  652                 (config_pair.first == 
"authoritative") ||
 
  653                 (config_pair.first == 
"next-server") ||
 
  654                 (config_pair.first == 
"server-hostname") ||
 
  655                 (config_pair.first == 
"boot-file-name") ||
 
  656                 (config_pair.first == 
"server-tag") ||
 
  657                 (config_pair.first == 
"reservations-global") ||
 
  658                 (config_pair.first == 
"reservations-in-subnet") ||
 
  659                 (config_pair.first == 
"reservations-out-of-pool") ||
 
  660                 (config_pair.first == 
"calculate-tee-times") ||
 
  661                 (config_pair.first == 
"t1-percent") ||
 
  662                 (config_pair.first == 
"t2-percent") ||
 
  663                 (config_pair.first == 
"cache-threshold") ||
 
  664                 (config_pair.first == 
"cache-max-age") ||
 
  665                 (config_pair.first == 
"hostname-char-set") ||
 
  666                 (config_pair.first == 
"hostname-char-replacement") ||
 
  667                 (config_pair.first == 
"ddns-send-updates") ||
 
  668                 (config_pair.first == 
"ddns-override-no-update") ||
 
  669                 (config_pair.first == 
"ddns-override-client-update") ||
 
  670                 (config_pair.first == 
"ddns-replace-client-name") ||
 
  671                 (config_pair.first == 
"ddns-generated-prefix") ||
 
  672                 (config_pair.first == 
"ddns-qualifying-suffix") ||
 
  673                 (config_pair.first == 
"ddns-update-on-renew") ||
 
  674                 (config_pair.first == 
"ddns-use-conflict-resolution") ||
 
  675                 (config_pair.first == 
"ddns-conflict-resolution-mode") ||
 
  676                 (config_pair.first == 
"ddns-ttl-percent") ||
 
  677                 (config_pair.first == 
"store-extended-info") ||
 
  678                 (config_pair.first == 
"statistic-default-sample-count") ||
 
  679                 (config_pair.first == 
"statistic-default-sample-age") ||
 
  680                 (config_pair.first == 
"early-global-reservations-lookup") ||
 
  681                 (config_pair.first == 
"ip-reservations-unique") ||
 
  682                 (config_pair.first == 
"reservations-lookup-first") ||
 
  683                 (config_pair.first == 
"parked-packet-limit") ||
 
  684                 (config_pair.first == 
"allocator") ||
 
  685                 (config_pair.first == 
"offer-lifetime") ||
 
  686                 (config_pair.first == 
"ddns-ttl") ||
 
  687                 (config_pair.first == 
"ddns-ttl-min") ||
 
  688                 (config_pair.first == 
"ddns-ttl-max") ||
 
  689                 (config_pair.first == 
"stash-agent-options")) {
 
  696            if (config_pair.first == 
"user-context") {
 
  702                      "unsupported global configuration parameter: " << config_pair.first
 
  703                      << 
" (" << config_pair.second->getPosition() << 
")");
 
  707        parameter_name = 
"<post parsing>";
 
  710        global_parser.parse(srv_config, mutable_cfg);
 
  715        global_parser.sanityChecks(srv_config, mutable_cfg);
 
  718        if (!d2_client_cfg) {
 
  721        d2_client_cfg->validateContents();
 
  722        srv_config->setD2ClientConfig(d2_client_cfg);
 
  725                  .arg(parameter_name).arg(ex.
what());
 
  736                                           "Control-socket, hook-libraries, and D2 configuration " 
  737                                           "were sanity checked, but not applied.");
 
 
  745                     bool check_only, 
bool extra_checks) {
 
  748                                                           "Can't parse NULL config");
 
  769                std::ostringstream err;
 
  779                } 
catch (
const std::exception& ex) {
 
  780                    err << 
"Error setting packet queue controls after server reconfiguration: " 
  803            string parameter_name;
 
  812                mutable_cfg = boost::const_pointer_cast<Element>(config_set);
 
  816                    parameter_name = 
"interfaces-config";
 
  820                    parser.
parse(cfg_iface, ifaces_config);
 
  824                          .arg(parameter_name).arg(ex.
what());
 
  831                                                   " processing error");
 
  891            bool multi_threading_enabled = 
true;
 
  892            uint32_t thread_count = 0;
 
  893            uint32_t queue_size = 0;
 
  895                                       multi_threading_enabled, thread_count, queue_size);
 
  916                string params = 
"universe=4 persist=false";
 
  917                cfg_db->setAppendedParameters(params);
 
  918                cfg_db->createManagers();
 
  919            } 
catch (
const std::exception& ex) {
 
  943                                                       CBControlDHCPv4::FetchMode::FETCH_ALL);
 
  945            std::ostringstream err;
 
  946            err << 
"during update from config backend database: " << ex.
what();
 
  952            std::ostringstream err;
 
  953            err << 
"during update from config backend database: " 
  954                << 
"undefined configuration parsing error";
 
  969            if (notify_libraries) {
 
  970                return (notify_libraries);
 
  977            } 
catch (
const std::exception& ex) {
 
  978                std::ostringstream err;
 
  979                err << 
"Error initializing hooks: " 
 
This is a base class for exceptions thrown from the DNS library module.
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
void clearIOServices()
Clear the list of IOService objects.
static IOServiceMgr & instance()
Access the IOServiceMgr singleton instance.
void pollIOServices()
Poll IOService objects.
void logRegistered()
Logs out all registered backends.
static std::string getHash(const isc::data::ConstElementPtr &config)
returns a hash of a given Element structure
void closeCommandSockets()
Close http control sockets.
static HttpCommandMgr & instance()
HttpCommandMgr is a singleton class.
void openCommandSockets(const isc::data::ConstElementPtr config)
Open http control sockets using configuration.
static UnixCommandMgr & instance()
UnixCommandMgr is a singleton class.
void openCommandSockets(const isc::data::ConstElementPtr config)
Opens unix control socket with parameters specified in socket_info (required parameters: socket-type:...
void closeCommandSockets()
Shuts down any open unix control sockets.
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.
Parse Database Parameters.
void parse(std::string &access_string, isc::data::ConstElementPtr database_config)
Parse configuration value.
void setD2ClientConfig(D2ClientConfigPtr &new_config)
Updates the DHCP-DDNS client configuration to the given value.
static CfgMgr & instance()
returns a single instance of Configuration Manager
SrvConfigPtr getStagingCfg()
Returns a pointer to the staging configuration.
SrvConfigPtr getCurrentCfg()
Returns a pointer to the current configuration.
static void extract(data::ConstElementPtr value, bool &enabled, uint32_t &thread_count, uint32_t &queue_size)
Extract multi-threading parameters from a given configuration.
Parser for a list of client class definitions.
ClientClassDictionaryPtr parse(isc::data::ConstElementPtr class_def_list, uint16_t family, bool check_dependencies=true)
Parse configuration entries.
void parse(isc::data::ConstElementPtr cfg, isc::dhcp::SrvConfig &srv_cfg)
Parse compatibility flags.
static ConfigBackendDHCPv4Mgr & instance()
Returns a sole instance of the ConfigBackendDHCPv4Mgr.
Parser for the control-sockets structure.
void parse(SrvConfig &srv_cfg, isc::data::ConstElementPtr value)
"Parses" control-sockets structure
static isc::data::ConstElementPtr finishConfigHookLibraries(isc::data::ConstElementPtr config)
Configuration checker for hook libraries.
Parser for D2ClientConfig.
D2ClientConfigPtr parse(isc::data::ConstElementPtr d2_client_cfg)
Parses a given dhcp-ddns element into D2ClientConfig.
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.
Parser for the configuration of DHCP packet queue controls.
data::ElementPtr parse(const isc::data::ConstElementPtr &control_elem, bool multi_threading_enabled)
Parses content of the "dhcp-queue-control".
To be removed. Please use ConfigError instead.
CBControlDHCPv4Ptr getCBControl() const
Returns an object which controls access to the configuration backends.
void discardPackets()
Discards parked packets Clears the packet parking lots of all packets.
Parser for the configuration parameters pertaining to the processing of expired leases.
void parse(isc::data::ConstElementPtr expiration_config, isc::dhcp::CfgExpirationPtr expiration)
Parses parameters in the JSON map, pertaining to the processing of the expired leases.
static void logRegistered()
Logs out all registered backends.
Parser for a list of host identifiers for DHCPv4.
void parse(isc::data::ConstElementPtr ids_list)
Parses a list of host identifiers.
Parser for a list of host reservations for a subnet.
void parse(const SubnetID &subnet_id, isc::data::ConstElementPtr hr_list, HostCollection &hosts_list)
Parses a list of host reservation entries for a subnet.
static IfaceMgr & instance()
IfaceMgr is a singleton class.
void closeSockets()
Closes all open sockets.
Parser for the configuration of interfaces.
void parse(const CfgIfacePtr &config, const isc::data::ConstElementPtr &values)
Parses content of the "interfaces-config".
static void logRegistered()
Logs out all registered backends.
static void logRegistered()
Logs out all registered backends.
static void setRuntimeOptionDefs(const OptionDefSpaceContainer &defs)
Copies option definitions created at runtime.
static void revertRuntimeOptionDefs()
Reverts uncommitted changes to runtime option definitions.
Simple parser for multi-threading structure.
void parse(SrvConfig &srv_cfg, const isc::data::ConstElementPtr &value)
parses JSON structure.
Parser for option data values within a subnet.
void parse(const CfgOptionPtr &cfg, isc::data::ConstElementPtr option_data_list, bool encapsulate=true)
Parses a list of options, instantiates them and stores in cfg.
Parser for a list of option definitions.
void parse(CfgOptionDefPtr cfg, isc::data::ConstElementPtr def_list)
Parses a list of option definitions, create them and store in cfg.
Class of option definition space container.
Simple parser for sanity-checks structure.
void parse(SrvConfig &srv_cfg, const isc::data::ConstElementPtr &value)
parses JSON structure
void parse(CfgSharedNetworksTypePtr &cfg, const data::ConstElementPtr &shared_networks_list_data)
Parses a list of shared networks.
static size_t deriveParameters(isc::data::ElementPtr global)
Derives (inherits) all parameters from global to more specific scopes.
static size_t setAllDefaults(isc::data::ElementPtr global)
Sets all defaults for DHCPv4 configuration.
static const uint32_t CFGSEL_ALL4
IPv4 related config.
this class parses list of DHCP4 subnets
size_t parse(SrvConfigPtr cfg, data::ConstElementPtr subnets_list, bool encapsulate_options=true)
parses contents of the list
static const TimerMgrPtr & instance()
Returns pointer to the sole instance of the TimerMgr.
Wrapper class that holds hooks libraries configuration.
void verifyLibraries(const isc::data::Element::Position &position, bool multi_threading_enabled) const
Verifies that libraries stored in libraries_ are valid.
void loadLibraries(bool multi_threading_enabled) const
Commits hooks libraries configuration.
Parser for hooks library list.
void parse(HooksConfig &libraries, isc::data::ConstElementPtr value)
Parses parameters value.
static bool unloadLibraries()
Unload libraries.
static void prepareUnloadLibraries()
Prepare the unloading of libraries.
Implements parser for config control information, "config-control".
ConfigControlInfoPtr parse(const data::ConstElementPtr &config_control)
Parses a configuration control Element.
isc::data::ConstElementPtr redactConfig(isc::data::ConstElementPtr const &config)
Redact a configuration.
static MultiThreadingMgr & instance()
Returns a single instance of Multi Threading Manager.
void setTestMode(const bool test_mode)
Sets or clears the test mode for MultiThreadingMgr.
void apply(bool enabled, uint32_t thread_count, uint32_t queue_size)
Apply the multi-threading related settings.
Parsers for client class definitions.
This file contains several functions and constants that are used for handling commands and responses ...
Contains declarations for loggers used by the DHCPv4 server component.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
#define LOG_INFO(LOGGER, MESSAGE)
Macro to conveniently test info output and log it.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
#define LOG_DEBUG(LOGGER, LEVEL, MESSAGE)
Macro to conveniently test debug output and log it.
ConstElementPtr parseAnswer(int &rcode, const ConstElementPtr &msg)
Parses a standard config/command level answer and returns arguments or text status code.
const int CONTROL_RESULT_ERROR
Status code indicating a general failure.
ConstElementPtr createAnswer(const int status_code, const std::string &text, const ConstElementPtr &arg)
Creates a standard config/command level answer message.
ConstElementPtr createAnswer()
Creates a standard config/command level success answer message (i.e.
const int CONTROL_RESULT_SUCCESS
Status code indicating a successful operation.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< Element > ElementPtr
void configureCommandChannel()
Initialize the command channel based on the staging configuration.
const isc::log::MessageID DHCP4_CONFIG_START
boost::shared_ptr< D2ClientConfig > D2ClientConfigPtr
Defines a pointer for D2ClientConfig instances.
const isc::log::MessageID DHCP4_PARSER_EXCEPTION
boost::shared_ptr< CfgOption > CfgOptionPtr
Non-const pointer.
SharedNetworksListParser< SharedNetwork4Parser > SharedNetworks4ListParser
Type of the shared networks list parser for IPv4.
boost::shared_ptr< CfgOptionDef > CfgOptionDefPtr
Non-const pointer.
boost::shared_ptr< CfgDbAccess > CfgDbAccessPtr
A pointer to the CfgDbAccess.
const isc::log::MessageID DHCP4_RESERVATIONS_LOOKUP_FIRST_ENABLED
isc::data::ConstElementPtr processDhcp4Config(isc::data::ConstElementPtr config_set)
Process a DHCPv4 confguration and return an answer stating if the configuration is valid,...
boost::shared_ptr< CfgIface > CfgIfacePtr
A pointer to the CfgIface .
const isc::log::MessageID DHCP4_CONFIG_PACKET_QUEUE
const isc::log::MessageID DHCP4_PARSER_COMMIT_EXCEPTION
boost::shared_ptr< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
const isc::log::MessageID DHCP4_PARSER_FAIL
std::vector< HostPtr > HostCollection
Collection of the Host objects.
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 > > > > Subnet4SimpleCollection
A simple collection of Subnet4 objects.
const int DBG_DHCP4_COMMAND
Debug level used to log receiving commands.
const isc::log::MessageID DHCP4_PARSER_COMMIT_FAIL
boost::shared_ptr< ClientClassDictionary > ClientClassDictionaryPtr
Defines a pointer to a ClientClassDictionary.
isc::data::ConstElementPtr configureDhcp4Server(Dhcpv4Srv &server, isc::data::ConstElementPtr config_set, bool check_only, bool extra_checks)
Configure DHCPv4 server (Dhcpv4Srv) with a set of configuration values.
boost::shared_ptr< CfgSubnets4 > CfgSubnets4Ptr
Non-const pointer.
const isc::log::MessageID DHCP4_CONFIG_COMPLETE
boost::multi_index_container< SharedNetwork4Ptr, boost::multi_index::indexed_by< boost::multi_index::random_access< boost::multi_index::tag< SharedNetworkRandomAccessIndexTag > >, boost::multi_index::hashed_non_unique< boost::multi_index::tag< SharedNetworkIdIndexTag >, boost::multi_index::const_mem_fun< data::BaseStampedElement, uint64_t, &data::BaseStampedElement::getId > >, boost::multi_index::ordered_unique< boost::multi_index::tag< SharedNetworkNameIndexTag >, boost::multi_index::const_mem_fun< SharedNetwork4, std::string, &SharedNetwork4::getName > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SharedNetworkServerIdIndexTag >, boost::multi_index::const_mem_fun< Network4, asiolink::IOAddress, &Network4::getServerId > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SharedNetworkModificationTimeIndexTag >, boost::multi_index::const_mem_fun< data::BaseStampedElement, boost::posix_time::ptime, &data::BaseStampedElement::getModificationTime > > > > SharedNetwork4Collection
Multi index container holding shared networks.
boost::shared_ptr< CfgSharedNetworks4 > CfgSharedNetworks4Ptr
Pointer to the configuration of IPv4 shared networks.
isc::log::Logger dhcp4_logger(DHCP4_APP_LOGGER_NAME)
Base logger for DHCPv4 server.
boost::shared_ptr< ConfigControlInfo > ConfigControlInfoPtr
Defines a pointer to a ConfigControlInfo.
Defines the logger used by the top-level component of kea-lfc.
static data::ElementPtr toElement(data::ConstElementPtr map)
Copy an Element map.