56#include <boost/algorithm/string.hpp> 
   57#include <boost/lexical_cast.hpp> 
   58#include <boost/scoped_ptr.hpp> 
   59#include <boost/shared_ptr.hpp> 
   64#include <netinet/in.h> 
  105            for (
auto const& source_elem : value->listValue()) {
 
  106                std::string option_str = source_elem->stringValue();
 
  110                    code = boost::lexical_cast<int64_t>(option_str);
 
  113                        isc_throw(BadValue, 
"invalid option code value specified '" 
  114                                  << option_str << 
"', the option code must be a" 
  115                                  " non-negative value");
 
  117                    } 
else if (code > std::numeric_limits<uint16_t>::max()) {
 
  118                        isc_throw(BadValue, 
"invalid option code value specified '" 
  119                                  << option_str << 
"', the option code must not be" 
  120                                  " greater than '" << std::numeric_limits<uint16_t>::max()
 
  124                } 
catch (
const boost::bad_lexical_cast &) {
 
  132                        code = def->getCode();
 
  134                        isc_throw(BadValue, 
"unable to find option code for the " 
  135                                  " specified option name '" << option_str << 
"'" 
  136                                  " while parsing the list of enabled" 
  137                                  " relay-supplied-options");
 
  140                cfg->getCfgRSOO()->enable(code);
 
  142        } 
catch (
const std::exception& ex) {
 
  145            isc_throw(DhcpConfigError, ex.what() << 
" (" << value->getPosition() << 
")");
 
  178        if (global->contains(
"data-directory")) {
 
  179            auto dd = getString(global, 
"data-directory");
 
  182                          "'data-directory' of '" << dd << 
"' is invalid," 
  183                          << 
" supported path is '" 
  191        uint32_t probation_period =
 
  192            getUint32(global, 
"decline-probation-period");
 
  193        cfg->setDeclinePeriod(probation_period);
 
  196        uint16_t dhcp4o6_port = getUint16(global, 
"dhcp4o6-port");
 
  197        cfg->setDhcp4o6Port(dhcp4o6_port);
 
  202            cfg->setContext(user_context);
 
  206        std::string server_tag = getString(global, 
"server-tag");
 
  207        cfg->setServerTag(server_tag);
 
  223        bool ip_reservations_unique = getBoolean(global, 
"ip-reservations-unique");
 
  224        cfg->setIPReservationsUnique(ip_reservations_unique);
 
  236        if (!dest || !from) {
 
  237            isc_throw(BadValue, 
"Unable to copy subnets: at least one pointer is null");
 
  248        for (
auto const& net : *networks) {
 
  259            for (
auto const& subnet : *subnets) {
 
  277        cfg->sanityChecksLifetime(
"preferred-lifetime");
 
  278        cfg->sanityChecksLifetime(
"valid-lifetime");
 
  281        cfg->sanityChecksDdnsTtlParameters();
 
  286            sharedNetworksSanityChecks(*networks, global->get(
"shared-networks"));
 
  308        std::set<string> names;
 
  311        for (
auto const& net : networks) {
 
  316            string iface = net->getIface();
 
  321                bool rapid_commit = 
false;
 
  325                if (subnets->size()) {
 
  327                    rapid_commit = (*subnets->begin())->getRapidCommit();
 
  331                for (
auto const& subnet : *subnets) {
 
  334                    if (rapid_commit != subnet->getRapidCommit()) {
 
  335                        isc_throw(DhcpConfigError, 
"All subnets in a shared network " 
  336                                  "must have the same rapid-commit value. Subnet " 
  338                                  << 
" has specified rapid-commit " 
  339                                  << (subnet->getRapidCommit() ? 
"true" : 
"false")
 
  340                                  << 
", but earlier subnet in the same shared-network" 
  341                                  << 
" or the shared-network itself used rapid-commit " 
  342                                  << (rapid_commit ? 
"true" : 
"false"));
 
  346                        iface = subnet->getIface();
 
  350                    if (subnet->getIface().empty()) {
 
  354                    if (subnet->getIface() != iface) {
 
  355                        isc_throw(DhcpConfigError, 
"Subnet " << subnet->toText()
 
  356                                  << 
" has specified interface " << subnet->getIface()
 
  357                                  << 
", but earlier subnet in the same shared-network" 
  358                                  << 
" or the shared-network itself used " << iface);
 
  363                    txt += subnet->toText() + 
" ";
 
  368            if (net->getName().empty()) {
 
  369                isc_throw(DhcpConfigError, 
"Shared-network with subnets " 
  370                          << txt << 
" is missing mandatory 'name' parameter");
 
  374            if (names.find(net->getName()) != names.end()) {
 
  375                isc_throw(DhcpConfigError, 
"A shared-network with " 
  376                          "name " << net->getName() << 
" defined twice.");
 
  378            names.insert(net->getName());
 
  408    bool sock_changed = (unix_config && current_unix_config &&
 
  409                         !unix_config->equals(*current_unix_config));
 
  416    if (!unix_config || !current_unix_config || sock_changed) {
 
  423        } 
else if (current_unix_config) {
 
  438    } 
else if (current_http_config) {
 
  459    string parameter_name;
 
  469        mutable_cfg = boost::const_pointer_cast<Element>(config_set);
 
  484        Dhcp6ConfigParser global_parser;
 
  487        global_parser.parseEarly(srv_config, mutable_cfg);
 
  492            parameter_name = 
"option-def";
 
  495            parser.
parse(cfg_option_def, option_defs);
 
  500            parameter_name = 
"option-data";
 
  503            parser.
parse(cfg_option, option_datas);
 
  508            parameter_name = 
"mac-sources";
 
  511            parser.
parse(mac_source, mac_sources);
 
  515        if (control_socket) {
 
  516            mutable_cfg->remove(
"control-socket");
 
  519            mutable_cfg->set(
"control-sockets", l);
 
  523        if (control_sockets) {
 
  524            parameter_name = 
"control-sockets";
 
  526            parser.
parse(*srv_config, control_sockets);
 
  530        if (multi_threading) {
 
  531            parameter_name = 
"multi-threading";
 
  533            parser.
parse(*srv_config, multi_threading);
 
  536        bool multi_threading_enabled = 
true;
 
  537        uint32_t thread_count = 0;
 
  538        uint32_t queue_size = 0;
 
  540                                   multi_threading_enabled, thread_count, queue_size);
 
  543        ConstElementPtr queue_control = mutable_cfg->get(
"dhcp-queue-control");
 
  545            parameter_name = 
"dhcp-queue-control";
 
  547            srv_config->setDHCPQueueControl(parser.
parse(queue_control, multi_threading_enabled));
 
  551        ConstElementPtr reservations_lookup_first = mutable_cfg->get(
"reservations-lookup-first");
 
  552        if (reservations_lookup_first) {
 
  553            parameter_name = 
"reservations-lookup-first";
 
  554            if (multi_threading_enabled) {
 
  557            srv_config->setReservationsLookupFirst(reservations_lookup_first->boolValue());
 
  561            mutable_cfg->get(
"host-reservation-identifiers");
 
  562        if (hr_identifiers) {
 
  563            parameter_name = 
"host-reservation-identifiers";
 
  565            parser.
parse(hr_identifiers);
 
  570            parameter_name = 
"server-id";
 
  572            const CfgDUIDPtr& cfg = srv_config->getCfgDUID();
 
  573            parser.
parse(cfg, server_id);
 
  578            parameter_name = 
"sanity-checks";
 
  580            parser.
parse(*srv_config, sanity_checks);
 
  584            mutable_cfg->get(
"expired-leases-processing");
 
  585        if (expiration_cfg) {
 
  586            parameter_name = 
"expired-leases-processing";
 
  595        if (hooks_libraries) {
 
  596            parameter_name = 
"hooks-libraries";
 
  598            HooksConfig& libraries = srv_config->getHooksConfig();
 
  599            hooks_parser.
parse(libraries, hooks_libraries);
 
  601                                      multi_threading_enabled);
 
  610            parameter_name = 
"dhcp-ddns";
 
  618        if (client_classes) {
 
  619            parameter_name = 
"client-classes";
 
  622                parser.
parse(client_classes, AF_INET6);
 
  623            srv_config->setClientClassDictionary(dictionary);
 
  628        if (lease_database) {
 
  629            parameter_name = 
"lease-database";
 
  631            std::string access_string;
 
  632            parser.
parse(access_string, lease_database);
 
  634            cfg_db_access->setLeaseDbAccessString(access_string);
 
  638        if (hosts_database) {
 
  639            parameter_name = 
"hosts-database";
 
  641            std::string access_string;
 
  642            parser.
parse(access_string, hosts_database);
 
  644            cfg_db_access->setHostDbAccessString(access_string);
 
  648        if (hosts_databases) {
 
  649            parameter_name = 
"hosts-databases";
 
  651            for (
auto const& it : hosts_databases->listValue()) {
 
  653                std::string access_string;
 
  654                parser.
parse(access_string, it);
 
  655                cfg_db_access->setHostDbAccessString(access_string);
 
  661        if (shared_networks) {
 
  662            parameter_name = 
"shared-networks";
 
  670            parser.
parse(cfg, shared_networks);
 
  674            global_parser.copySubnets6(srv_config->getCfgSubnets6(), cfg);
 
  679            parameter_name = 
"subnet6";
 
  682            subnets_parser.
parse(srv_config, subnet6);
 
  687            parameter_name = 
"reservations";
 
  690            parser.
parse(SUBNET_ID_GLOBAL, reservations, hosts);
 
  691            for (
auto const& h : hosts) {
 
  692                srv_config->getCfgHosts()->add(h);
 
  697        if (config_control) {
 
  698            parameter_name = 
"config-control";
 
  704        ConstElementPtr rsoo_list = mutable_cfg->get(
"relay-supplied-options");
 
  706            parameter_name = 
"relay-supplied-options";
 
  707            RSOOListConfigParser parser;
 
  708            parser.parse(srv_config, rsoo_list);
 
  718        const std::map<std::string, ConstElementPtr>& values_map =
 
  719            mutable_cfg->mapValue();
 
  721        for (
auto const& config_pair : values_map) {
 
  722            parameter_name = config_pair.first;
 
  725            if ((config_pair.first == 
"data-directory") ||
 
  726                (config_pair.first == 
"option-def")  ||
 
  727                (config_pair.first == 
"option-data") ||
 
  728                (config_pair.first == 
"mac-sources") ||
 
  729                (config_pair.first == 
"control-socket") ||
 
  730                (config_pair.first == 
"control-sockets") ||
 
  731                (config_pair.first == 
"multi-threading") ||
 
  732                (config_pair.first == 
"dhcp-queue-control") ||
 
  733                (config_pair.first == 
"host-reservation-identifiers") ||
 
  734                (config_pair.first == 
"server-id") ||
 
  735                (config_pair.first == 
"interfaces-config") ||
 
  736                (config_pair.first == 
"sanity-checks") ||
 
  737                (config_pair.first == 
"expired-leases-processing") ||
 
  738                (config_pair.first == 
"hooks-libraries") ||
 
  739                (config_pair.first == 
"dhcp-ddns") ||
 
  740                (config_pair.first == 
"client-classes") ||
 
  741                (config_pair.first == 
"lease-database") ||
 
  742                (config_pair.first == 
"hosts-database") ||
 
  743                (config_pair.first == 
"hosts-databases") ||
 
  744                (config_pair.first == 
"subnet6") ||
 
  745                (config_pair.first == 
"shared-networks") ||
 
  746                (config_pair.first == 
"reservations") ||
 
  747                (config_pair.first == 
"config-control") ||
 
  748                (config_pair.first == 
"relay-supplied-options") ||
 
  749                (config_pair.first == 
"loggers") ||
 
  750                (config_pair.first == 
"compatibility")) {
 
  764            if ( (config_pair.first == 
"renew-timer") ||
 
  765                 (config_pair.first == 
"rebind-timer") ||
 
  766                 (config_pair.first == 
"preferred-lifetime") ||
 
  767                 (config_pair.first == 
"min-preferred-lifetime") ||
 
  768                 (config_pair.first == 
"max-preferred-lifetime") ||
 
  769                 (config_pair.first == 
"valid-lifetime") ||
 
  770                 (config_pair.first == 
"min-valid-lifetime") ||
 
  771                 (config_pair.first == 
"max-valid-lifetime") ||
 
  772                 (config_pair.first == 
"decline-probation-period") ||
 
  773                 (config_pair.first == 
"dhcp4o6-port") ||
 
  774                 (config_pair.first == 
"server-tag") ||
 
  775                 (config_pair.first == 
"reservations-global") ||
 
  776                 (config_pair.first == 
"reservations-in-subnet") ||
 
  777                 (config_pair.first == 
"reservations-out-of-pool") ||
 
  778                 (config_pair.first == 
"calculate-tee-times") ||
 
  779                 (config_pair.first == 
"t1-percent") ||
 
  780                 (config_pair.first == 
"t2-percent") ||
 
  781                 (config_pair.first == 
"cache-threshold") ||
 
  782                 (config_pair.first == 
"cache-max-age") ||
 
  783                 (config_pair.first == 
"hostname-char-set") ||
 
  784                 (config_pair.first == 
"hostname-char-replacement") ||
 
  785                 (config_pair.first == 
"ddns-send-updates") ||
 
  786                 (config_pair.first == 
"ddns-override-no-update") ||
 
  787                 (config_pair.first == 
"ddns-override-client-update") ||
 
  788                 (config_pair.first == 
"ddns-replace-client-name") ||
 
  789                 (config_pair.first == 
"ddns-generated-prefix") ||
 
  790                 (config_pair.first == 
"ddns-qualifying-suffix") ||
 
  791                 (config_pair.first == 
"ddns-update-on-renew") ||
 
  792                 (config_pair.first == 
"ddns-use-conflict-resolution") ||
 
  793                 (config_pair.first == 
"ddns-conflict-resolution-mode") ||
 
  794                 (config_pair.first == 
"ddns-ttl-percent") ||
 
  795                 (config_pair.first == 
"store-extended-info") ||
 
  796                 (config_pair.first == 
"statistic-default-sample-count") ||
 
  797                 (config_pair.first == 
"statistic-default-sample-age") ||
 
  798                 (config_pair.first == 
"early-global-reservations-lookup") ||
 
  799                 (config_pair.first == 
"ip-reservations-unique") ||
 
  800                 (config_pair.first == 
"reservations-lookup-first") ||
 
  801                 (config_pair.first == 
"parked-packet-limit") ||
 
  802                 (config_pair.first == 
"allocator") ||
 
  803                 (config_pair.first == 
"ddns-ttl") ||
 
  804                 (config_pair.first == 
"ddns-ttl-min") ||
 
  805                 (config_pair.first == 
"ddns-ttl-max") ||
 
  806                 (config_pair.first == 
"pd-allocator") ) {
 
  813            if (config_pair.first == 
"user-context") {
 
  819                      "unsupported global configuration parameter: " << config_pair.first
 
  820                      << 
" (" << config_pair.second->getPosition() << 
")");
 
  824        parameter_name = 
"<post parsing>";
 
  827        global_parser.parse(srv_config, mutable_cfg);
 
  832        global_parser.sanityChecks(srv_config, mutable_cfg);
 
  835        if (!d2_client_cfg) {
 
  838        d2_client_cfg->validateContents();
 
  839        srv_config->setD2ClientConfig(d2_client_cfg);
 
  842                  .arg(parameter_name).arg(ex.
what());
 
  853                                           "Control-socket, hook-libraries, and D2 configuration " 
  854                                           "were sanity checked, but not applied.");
 
 
  862                     bool check_only, 
bool extra_checks) {
 
  865                                                           "Can't parse NULL config");
 
  886                std::ostringstream err;
 
  896                } 
catch (
const std::exception& ex) {
 
  897                    err << 
"Error setting packet queue controls after server reconfiguration: " 
  920            string parameter_name;
 
  929                mutable_cfg = boost::const_pointer_cast<Element>(config_set);
 
  933                    parameter_name = 
"interfaces-config";
 
  937                    parser.
parse(cfg_iface, ifaces_config);
 
  941                          .arg(parameter_name).arg(ex.
what());
 
  948                                                   " processing error");
 
 1008            bool multi_threading_enabled = 
true;
 
 1009            uint32_t thread_count = 0;
 
 1010            uint32_t queue_size = 0;
 
 1012                                       multi_threading_enabled, thread_count, queue_size);
 
 1033                string params = 
"universe=6 persist=false";
 
 1034                if (cfg_db->getExtendedInfoTablesEnabled()) {
 
 1035                    params += 
" extended-info-tables=true";
 
 1037                cfg_db->setAppendedParameters(params);
 
 1038                cfg_db->createManagers();
 
 1039            } 
catch (
const std::exception& ex) {
 
 1063                                                       CBControlDHCPv6::FetchMode::FETCH_ALL);
 
 1065            std::ostringstream err;
 
 1066            err << 
"during update from config backend database: " << ex.
what();
 
 1072            std::ostringstream err;
 
 1073            err << 
"during update from config backend database: " 
 1074                << 
"undefined configuration parsing error";
 
 1089            if (notify_libraries) {
 
 1090                return (notify_libraries);
 
 1097            } 
catch (
const std::exception& ex) {
 
 1098                std::ostringstream err;
 
 1099                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.
Wrapper class that holds MAC/hardware address sources.
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 ConfigBackendDHCPv6Mgr & instance()
Returns a sole instance of the ConfigBackendDHCPv6Mgr.
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".
Parser for server DUID configuration.
void parse(const CfgDUIDPtr &cfg, isc::data::ConstElementPtr duid_configuration)
Parses DUID configuration.
To be removed. Please use ConfigError instead.
CBControlDHCPv6Ptr 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 DHCPv6.
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 OptionDefinitionPtr getOptionDef(const std::string &space, const uint16_t code)
Return the first option definition matching a particular option code.
static void revertRuntimeOptionDefs()
Reverts uncommitted changes to runtime option definitions.
parser for MAC/hardware acquisition sources
void parse(CfgMACSource &mac_sources, isc::data::ConstElementPtr value)
parses parameters value
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 DHCPv6 configuration.
static const uint32_t CFGSEL_ALL6
IPv6 related config.
this class parses a list of DHCP6 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 ...
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Logging initialization functions.
#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.
boost::shared_ptr< CfgDUID > CfgDUIDPtr
Pointer to the Non-const object.
const isc::log::MessageID DHCP6_PARSER_FAIL
const isc::log::MessageID DHCP6_PARSER_EXCEPTION
boost::shared_ptr< D2ClientConfig > D2ClientConfigPtr
Defines a pointer for D2ClientConfig instances.
boost::shared_ptr< CfgOption > CfgOptionPtr
Non-const pointer.
boost::multi_index_container< SharedNetwork6Ptr, 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< SharedNetwork6, std::string, &SharedNetwork6::getName > >, 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 > > > > SharedNetwork6Collection
Multi index container holding shared networks.
const isc::log::MessageID DHCP6_DATA_DIRECTORY_DEPRECATED
isc::data::ConstElementPtr configureDhcp6Server(Dhcpv6Srv &server, isc::data::ConstElementPtr config_set, bool check_only, bool extra_checks)
Configure DHCPv6 server (Dhcpv6Srv) with a set of configuration values.
boost::shared_ptr< CfgOptionDef > CfgOptionDefPtr
Non-const pointer.
boost::shared_ptr< CfgDbAccess > CfgDbAccessPtr
A pointer to the CfgDbAccess.
isc::data::ConstElementPtr processDhcp6Config(isc::data::ConstElementPtr config_set)
Process a DHCPv6 confguration and return an answer stating if the configuration is valid,...
const int DBG_DHCP6_COMMAND
Debug level used to log receiving commands.
const isc::log::MessageID DHCP6_CONFIG_COMPLETE
boost::shared_ptr< CfgIface > CfgIfacePtr
A pointer to the CfgIface .
boost::shared_ptr< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
boost::shared_ptr< CfgSubnets6 > CfgSubnets6Ptr
Non-const pointer.
std::vector< HostPtr > HostCollection
Collection of the Host objects.
const isc::log::MessageID DHCP6_RESERVATIONS_LOOKUP_FIRST_ENABLED
boost::shared_ptr< OptionDefinition > OptionDefinitionPtr
Pointer to option definition object.
boost::shared_ptr< ClientClassDictionary > ClientClassDictionaryPtr
Defines a pointer to a ClientClassDictionary.
boost::shared_ptr< CfgSharedNetworks6 > CfgSharedNetworks6Ptr
Pointer to the configuration of IPv6 shared networks.
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 > > > > Subnet6SimpleCollection
A simple collection of Subnet6 objects.
const isc::log::MessageID DHCP6_PARSER_COMMIT_EXCEPTION
const isc::log::MessageID DHCP6_CONFIG_START
SharedNetworksListParser< SharedNetwork6Parser > SharedNetworks6ListParser
Type of the shared networks list parser for IPv6.
const isc::log::MessageID DHCP6_PARSER_COMMIT_FAIL
isc::log::Logger dhcp6_logger(DHCP6_APP_LOGGER_NAME)
Base logger for DHCPv6 server.
const isc::log::MessageID DHCP6_CONFIG_PACKET_QUEUE
boost::shared_ptr< ConfigControlInfo > ConfigControlInfoPtr
Defines a pointer to a ConfigControlInfo.
Defines the logger used by the top-level component of kea-lfc.
#define DHCP6_OPTION_SPACE
static data::ElementPtr toElement(data::ConstElementPtr map)
Copy an Element map.