Kea 3.0.0
srv_config.cc
Go to the documentation of this file.
1// Copyright (C) 2014-2025 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8
9#include <cc/simple_parser.h>
11#include <dhcpsrv/cfgmgr.h>
22#include <dhcpsrv/srv_config.h>
24#include <dhcpsrv/dhcpsrv_log.h>
27#include <log/logger_manager.h>
29#include <dhcp/pkt.h>
30#include <stats/stats_mgr.h>
31#include <util/str.h>
32
33#include <boost/make_shared.hpp>
34
35#include <list>
36#include <sstream>
37
38using namespace isc::log;
39using namespace isc::data;
40using namespace isc::process;
41
42namespace isc {
43namespace dhcp {
44
46 : sequence_(0), cfg_iface_(new CfgIface()),
47 cfg_option_def_(new CfgOptionDef()), cfg_option_(new CfgOption()),
48 cfg_subnets4_(new CfgSubnets4()), cfg_subnets6_(new CfgSubnets6()),
49 cfg_shared_networks4_(new CfgSharedNetworks4()),
50 cfg_shared_networks6_(new CfgSharedNetworks6()),
51 cfg_hosts_(new CfgHosts()), cfg_rsoo_(new CfgRSOO()),
52 cfg_expiration_(new CfgExpiration()), cfg_duid_(new CfgDUID()),
53 cfg_db_access_(new CfgDbAccess()),
54 cfg_host_operations4_(CfgHostOperations::createConfig4()),
55 cfg_host_operations6_(CfgHostOperations::createConfig6()),
56 class_dictionary_(new ClientClassDictionary()),
57 decline_timer_(0), echo_v4_client_id_(true), dhcp4o6_port_(0),
58 d2_client_config_(new D2ClientConfig()),
59 configured_globals_(new CfgGlobals()), cfg_consist_(new CfgConsistency()),
60 lenient_option_parsing_(false), ignore_dhcp_server_identifier_(false),
61 ignore_rai_link_selection_(false), exclude_first_last_24_(false),
62 reservations_lookup_first_(false) {
63}
64
65SrvConfig::SrvConfig(const uint32_t sequence)
66 : sequence_(sequence), cfg_iface_(new CfgIface()),
67 cfg_option_def_(new CfgOptionDef()), cfg_option_(new CfgOption()),
68 cfg_subnets4_(new CfgSubnets4()), cfg_subnets6_(new CfgSubnets6()),
69 cfg_shared_networks4_(new CfgSharedNetworks4()),
70 cfg_shared_networks6_(new CfgSharedNetworks6()),
71 cfg_hosts_(new CfgHosts()), cfg_rsoo_(new CfgRSOO()),
72 cfg_expiration_(new CfgExpiration()), cfg_duid_(new CfgDUID()),
73 cfg_db_access_(new CfgDbAccess()),
74 cfg_host_operations4_(CfgHostOperations::createConfig4()),
75 cfg_host_operations6_(CfgHostOperations::createConfig6()),
76 class_dictionary_(new ClientClassDictionary()),
77 decline_timer_(0), echo_v4_client_id_(true), dhcp4o6_port_(0),
78 d2_client_config_(new D2ClientConfig()),
79 configured_globals_(new CfgGlobals()), cfg_consist_(new CfgConsistency()),
80 lenient_option_parsing_(false), ignore_dhcp_server_identifier_(false),
81 ignore_rai_link_selection_(false), exclude_first_last_24_(false),
82 reservations_lookup_first_(false) {
83}
84
85std::string
86SrvConfig::getConfigSummary(const uint32_t selection) const {
87 std::ostringstream s;
88 size_t subnets_num;
89 if ((selection & CFGSEL_SUBNET4) == CFGSEL_SUBNET4) {
90 subnets_num = getCfgSubnets4()->getAll()->size();
91 if (subnets_num > 0) {
92 s << "added IPv4 subnets: " << subnets_num;
93 } else {
94 s << "no IPv4 subnets!";
95 }
96 s << "; ";
97 }
98
99 if ((selection & CFGSEL_SUBNET6) == CFGSEL_SUBNET6) {
100 subnets_num = getCfgSubnets6()->getAll()->size();
101 if (subnets_num > 0) {
102 s << "added IPv6 subnets: " << subnets_num;
103 } else {
104 s << "no IPv6 subnets!";
105 }
106 s << "; ";
107 }
108
109 if ((selection & CFGSEL_DDNS) == CFGSEL_DDNS) {
110 bool ddns_enabled = getD2ClientConfig()->getEnableUpdates();
111 s << "DDNS: " << (ddns_enabled ? "enabled" : "disabled") << "; ";
112 }
113
114 if (s.tellp() == static_cast<std::streampos>(0)) {
115 s << "no config details available";
116 }
117
118 std::string summary = s.str();
119 size_t last_separator_pos = summary.find_last_of(";");
120 if (last_separator_pos == summary.length() - 2) {
121 summary.erase(last_separator_pos);
122 }
123 return (summary);
124}
125
126bool
128 return (getSequence() == other.getSequence());
129}
130
131void
132SrvConfig::copy(SrvConfig& new_config) const {
133 ConfigBase::copy(new_config);
134
135 // Replace interface configuration.
136 new_config.cfg_iface_.reset(new CfgIface(*cfg_iface_));
137 // Replace option definitions.
138 cfg_option_def_->copyTo(*new_config.cfg_option_def_);
139 cfg_option_->copyTo(*new_config.cfg_option_);
140 // Replace the client class dictionary
141 new_config.class_dictionary_.reset(new ClientClassDictionary(*class_dictionary_));
142 // Replace the D2 client configuration
144 // Replace configured hooks libraries.
145 new_config.hooks_config_.clear();
146 using namespace isc::hooks;
147 for (auto const& it : hooks_config_.get()) {
148 new_config.hooks_config_.add(it.libname_, it.parameters_, it.cfgname_);
149 }
150}
151
152bool
153SrvConfig::equals(const SrvConfig& other) const {
154
155 // Checks common elements: logging & config control
156 if (!ConfigBase::equals(other)) {
157 return (false);
158 }
159
160 // Common information is equal between objects, so check other values.
161 if ((*cfg_iface_ != *other.cfg_iface_) ||
162 (*cfg_option_def_ != *other.cfg_option_def_) ||
163 (*cfg_option_ != *other.cfg_option_) ||
164 (*class_dictionary_ != *other.class_dictionary_) ||
165 (*d2_client_config_ != *other.d2_client_config_)) {
166 return (false);
167 }
168 // Now only configured hooks libraries can differ.
169 // If number of configured hooks libraries are different, then
170 // configurations aren't equal.
171 if (hooks_config_.get().size() != other.hooks_config_.get().size()) {
172 return (false);
173 }
174
175 // Pass through all configured hooks libraries.
176 return (hooks_config_.equal(other.hooks_config_));
177}
178
179void
181 ConfigBase::merge(other);
182 try {
183 SrvConfig& other_srv_config = dynamic_cast<SrvConfig&>(other);
184 // We merge objects in order of dependency (real or theoretical).
185 // First we merge the common stuff.
186
187 // Merge globals.
188 mergeGlobals(other_srv_config);
189
190 // Merge global maps.
191 mergeGlobalMaps(other_srv_config);
192
193 // Merge option defs. We need to do this next so we
194 // pass these into subsequent merges so option instances
195 // at each level can be created based on the merged
196 // definitions.
197 cfg_option_def_->merge(*other_srv_config.getCfgOptionDef());
198
199 // Merge options.
200 cfg_option_->merge(cfg_option_def_, *other_srv_config.getCfgOption());
201
202 if (!other_srv_config.getClientClassDictionary()->empty()) {
203 // Client classes are complicated because they are ordered and may
204 // depend on each other. Merging two lists of classes with preserving
205 // the order would be very involved and could result in errors. Thus,
206 // we simply replace the current list of classes with a new list.
207 setClientClassDictionary(boost::make_shared
208 <ClientClassDictionary>(*other_srv_config.getClientClassDictionary()));
209 }
210
211 if (CfgMgr::instance().getFamily() == AF_INET) {
212 merge4(other_srv_config);
213 } else {
214 merge6(other_srv_config);
215 }
216 } catch (const std::bad_cast&) {
217 isc_throw(InvalidOperation, "internal server error: must use derivation"
218 " of the SrvConfig as an argument of the call to"
219 " SrvConfig::merge()");
220 }
221}
222
223void
224SrvConfig::merge4(SrvConfig& other) {
225 // Merge shared networks.
226 cfg_shared_networks4_->merge(cfg_option_def_, *(other.getCfgSharedNetworks4()));
227
228 // Merge subnets.
229 cfg_subnets4_->merge(cfg_option_def_, getCfgSharedNetworks4(),
230 *(other.getCfgSubnets4()));
231
233}
234
235void
236SrvConfig::merge6(SrvConfig& other) {
237 // Merge shared networks.
238 cfg_shared_networks6_->merge(cfg_option_def_, *(other.getCfgSharedNetworks6()));
239
240 // Merge subnets.
241 cfg_subnets6_->merge(cfg_option_def_, getCfgSharedNetworks6(),
242 *(other.getCfgSubnets6()));
243
245}
246
247void
248SrvConfig::mergeGlobals(SrvConfig& other) {
249 auto config_set = getConfiguredGlobals();
250 // Iterate over the "other" globals, adding/overwriting them into
251 // this config's list of globals.
252 for (auto const& other_global : other.getConfiguredGlobals()->valuesMap()) {
253 addConfiguredGlobal(other_global.first, other_global.second);
254 }
255
256 // A handful of values are stored as members in SrvConfig. So we'll
257 // iterate over the merged globals, setting appropriate members.
258 for (auto const& merged_global : getConfiguredGlobals()->valuesMap()) {
259 std::string name = merged_global.first;
260 ConstElementPtr element = merged_global.second;
261 try {
262 if (name == "decline-probation-period") {
263 setDeclinePeriod(element->intValue());
264 } else if (name == "echo-client-id") {
265 // echo-client-id is v4 only, but we'll let upstream
266 // worry about that.
267 setEchoClientId(element->boolValue());
268 } else if (name == "dhcp4o6-port") {
269 setDhcp4o6Port(element->intValue());
270 } else if (name == "server-tag") {
271 setServerTag(element->stringValue());
272 } else if (name == "ip-reservations-unique") {
273 setIPReservationsUnique(element->boolValue());
274 } else if (name == "reservations-lookup-first") {
275 setReservationsLookupFirst(element->boolValue());
276 }
277 } catch(const std::exception& ex) {
278 isc_throw (BadValue, "Invalid value:" << element->str()
279 << " explicit global:" << name);
280 }
281 }
282}
283
284void
285SrvConfig::mergeGlobalMaps(SrvConfig& other) {
287 for (auto const& other_global : other.getConfiguredGlobals()->valuesMap()) {
288 config->set(other_global.first, other_global.second);
289 }
290 std::string parameter_name;
291 try {
292 ConstElementPtr compatibility = config->get("compatibility");
293 parameter_name = "compatibility";
294 if (compatibility) {
295 CompatibilityParser parser;
296 parser.parse(compatibility, *this);
297 addConfiguredGlobal("compatibility", compatibility);
298 }
299 ElementPtr dhcp_ddns = boost::const_pointer_cast<Element>(config->get("dhcp-ddns"));
300 parameter_name = "dhcp-ddns";
301 if (dhcp_ddns) {
302 // Apply defaults
304 D2ClientConfigParser parser;
305 // D2 client configuration.
306 D2ClientConfigPtr d2_client_cfg;
307 d2_client_cfg = parser.parse(dhcp_ddns);
308 if (!d2_client_cfg) {
309 d2_client_cfg.reset(new D2ClientConfig());
310 }
311 d2_client_cfg->validateContents();
312 setD2ClientConfig(d2_client_cfg);
313 addConfiguredGlobal("dhcp-ddns", dhcp_ddns);
314 }
315 ConstElementPtr expiration_cfg = config->get("expired-leases-processing");
316 parameter_name = "expired-leases-processing";
317 if (expiration_cfg) {
318 ExpirationConfigParser parser;
319 parser.parse(expiration_cfg, getCfgExpiration());
320 addConfiguredGlobal("expired-leases-processing", expiration_cfg);
321 }
322 ElementPtr multi_threading = boost::const_pointer_cast<Element>(config->get("multi-threading"));
323 parameter_name = "multi-threading";
324 if (multi_threading) {
325 if (CfgMgr::instance().getFamily() == AF_INET) {
327 } else {
329 }
330 MultiThreadingConfigParser parser;
331 parser.parse(*this, multi_threading);
332 addConfiguredGlobal("multi-threading", multi_threading);
333 }
334 bool multi_threading_enabled = true;
335 uint32_t thread_count = 0;
336 uint32_t queue_size = 0;
338 multi_threading_enabled, thread_count, queue_size);
339 ElementPtr sanity_checks = boost::const_pointer_cast<Element>(config->get("sanity-checks"));
340 parameter_name = "sanity-checks";
341 if (sanity_checks) {
342 if (CfgMgr::instance().getFamily() == AF_INET) {
344 } else {
346 }
347 SanityChecksParser parser;
348 parser.parse(*this, sanity_checks);
349 addConfiguredGlobal("multi-threading", sanity_checks);
350 }
351 ConstElementPtr server_id = config->get("server-id");
352 parameter_name = "server-id";
353 if (server_id) {
354 DUIDConfigParser parser;
355 const CfgDUIDPtr& cfg = getCfgDUID();
356 parser.parse(cfg, server_id);
357 addConfiguredGlobal("server-id", server_id);
358 }
359 ElementPtr queue_control = boost::const_pointer_cast<Element>(config->get("dhcp-queue-control"));
360 parameter_name = "dhcp-queue-control";
361 if (queue_control) {
362 if (CfgMgr::instance().getFamily() == AF_INET) {
364 } else {
366 }
367 DHCPQueueControlParser parser;
368 setDHCPQueueControl(parser.parse(queue_control, multi_threading_enabled));
369 addConfiguredGlobal("dhcp-queue-control", queue_control);
370 }
371 } catch (const isc::Exception& ex) {
372 isc_throw(BadValue, "Invalid parameter " << parameter_name << " error: " << ex.what());
373 } catch (...) {
374 isc_throw(BadValue, "Invalid parameter " << parameter_name);
375 }
376}
377
378void
380 // Removes statistics for v4 and v6 subnets
381 getCfgSubnets4()->removeStatistics();
382 getCfgSubnets6()->removeStatistics();
383}
384
385void
387 // Update default sample limits.
389 ConstElementPtr samples =
390 getConfiguredGlobal("statistic-default-sample-count");
391 uint32_t max_samples = 0;
392 if (samples) {
393 max_samples = samples->intValue();
394 stats_mgr.setMaxSampleCountDefault(max_samples);
395 if (max_samples != 0) {
396 stats_mgr.setMaxSampleCountAll(max_samples);
397 }
398 }
399 ConstElementPtr duration =
400 getConfiguredGlobal("statistic-default-sample-age");
401 if (duration) {
402 int64_t time_duration = duration->intValue();
403 auto max_age = std::chrono::seconds(time_duration);
404 stats_mgr.setMaxSampleAgeDefault(max_age);
405 if (max_samples == 0) {
406 stats_mgr.setMaxSampleAgeAll(max_age);
407 }
408 }
409
410 // Updating subnet statistics involves updating lease statistics, which
411 // is done by the LeaseMgr. Since servers with subnets, must have a
412 // LeaseMgr, we do not bother updating subnet stats for servers without
413 // a lease manager, such as D2. @todo We should probably examine why
414 // "SrvConfig" is being used by D2.
416 // Updates statistics for v4 and v6 subnets.
417 getCfgSubnets4()->updateStatistics();
418 getCfgSubnets6()->updateStatistics();
419 }
420}
421
422void
424 // Code from SimpleParser::setDefaults
425 // This is the position representing a default value. As the values
426 // we're inserting here are not present in whatever the config file
427 // came from, we need to make sure it's clearly labeled as default.
428 const Element::Position pos("<default-value>", 0, 0);
429
430 // Let's go over all parameters we have defaults for.
431 for (auto const& def_value : defaults) {
432
433 // Try if such a parameter is there. If it is, let's
434 // skip it, because user knows best *cough*.
435 ConstElementPtr x = getConfiguredGlobal(def_value.name_);
436 if (x) {
437 // There is such a value already, skip it.
438 continue;
439 }
440
441 // There isn't such a value defined, let's create the default
442 // value...
443 switch (def_value.type_) {
444 case Element::string: {
445 x.reset(new StringElement(def_value.value_, pos));
446 break;
447 }
448 case Element::integer: {
449 try {
450 int int_value = boost::lexical_cast<int>(def_value.value_);
451 x.reset(new IntElement(int_value, pos));
452 }
453 catch (const std::exception& ex) {
455 "Internal error. Integer value expected for: "
456 << def_value.name_ << ", value is: "
457 << def_value.value_ );
458 }
459
460 break;
461 }
462 case Element::boolean: {
463 bool bool_value;
464 if (def_value.value_ == std::string("true")) {
465 bool_value = true;
466 } else if (def_value.value_ == std::string("false")) {
467 bool_value = false;
468 } else {
470 "Internal error. Boolean value for "
471 << def_value.name_ << " specified as "
472 << def_value.value_ << ", expected true or false");
473 }
474 x.reset(new BoolElement(bool_value, pos));
475 break;
476 }
477 case Element::real: {
478 double dbl_value = boost::lexical_cast<double>(def_value.value_);
479 x.reset(new DoubleElement(dbl_value, pos));
480 break;
481 }
482 default:
483 // No default values for null, list or map
485 "Internal error. Incorrect default value type for "
486 << def_value.name_);
487 }
488 addConfiguredGlobal(def_value.name_, x);
489 }
490}
491
492void
494 if (config->getType() != Element::map) {
495 isc_throw(BadValue, "extractConfiguredGlobals must be given a map element");
496 }
497
498 const std::map<std::string, ConstElementPtr>& values = config->mapValue();
499 for (auto const& value : values) {
500 if (value.second->getType() != Element::list &&
501 value.second->getType() != Element::map) {
502 addConfiguredGlobal(value.first, value.second);
503 }
504 }
505}
506
507void
508SrvConfig::sanityChecksLifetime(const std::string& name) const {
509 // Initialize as some compilers complain otherwise.
510 uint32_t value = 0;
511 ConstElementPtr has_value = getConfiguredGlobal(name);
512 if (has_value) {
513 value = has_value->intValue();
514 }
515
516 uint32_t min_value = 0;
517 ConstElementPtr has_min = getConfiguredGlobal("min-" + name);
518 if (has_min) {
519 min_value = has_min->intValue();
520 }
521
522 uint32_t max_value = 0;
523 ConstElementPtr has_max = getConfiguredGlobal("max-" + name);
524 if (has_max) {
525 max_value = has_max->intValue();
526 }
527
528 if (!has_value && !has_min && !has_max) {
529 return;
530 }
531 if (has_value) {
532 if (!has_min && !has_max) {
533 // default only.
534 return;
535 } else if (!has_min) {
536 // default and max.
537 min_value = value;
538 } else if (!has_max) {
539 // default and min.
540 max_value = value;
541 }
542 } else if (has_min) {
543 if (!has_max) {
544 // min only.
545 return;
546 } else {
547 // min and max.
548 isc_throw(BadValue, "have min-" << name << " and max-"
549 << name << " but no " << name << " (default)");
550 }
551 } else {
552 // max only.
553 return;
554 }
555
556 // Check that min <= max.
557 if (min_value > max_value) {
558 if (has_min && has_max) {
559 isc_throw(BadValue, "the value of min-" << name << " ("
560 << min_value << ") is not less than max-" << name << " ("
561 << max_value << ")");
562 } else if (has_min) {
563 // Only min and default so min > default.
564 isc_throw(BadValue, "the value of min-" << name << " ("
565 << min_value << ") is not less than (default) " << name
566 << " (" << value << ")");
567 } else {
568 // Only default and max so default > max.
569 isc_throw(BadValue, "the value of (default) " << name
570 << " (" << value << ") is not less than max-" << name
571 << " (" << max_value << ")");
572 }
573 }
574
575 // Check that value is between min and max.
576 if ((value < min_value) || (value > max_value)) {
577 isc_throw(BadValue, "the value of (default) " << name << " ("
578 << value << ") is not between min-" << name << " ("
579 << min_value << ") and max-" << name << " ("
580 << max_value << ")");
581 }
582}
583
584void
586 const std::string& name) const {
587 // Three cases:
588 // - the external/source config has the parameter: use it.
589 // - only the target config has the parameter: use this one.
590 // - no config has the parameter.
591 uint32_t value = 0;
592 ConstElementPtr has_value = getConfiguredGlobal(name);
593 bool new_value = true;
594 if (!has_value) {
595 has_value = target_config.getConfiguredGlobal(name);
596 new_value = false;
597 }
598 if (has_value) {
599 value = has_value->intValue();
600 }
601
602 uint32_t min_value = 0;
603 ConstElementPtr has_min = getConfiguredGlobal("min-" + name);
604 bool new_min = true;
605 if (!has_min) {
606 has_min = target_config.getConfiguredGlobal("min-" + name);
607 new_min = false;
608 }
609 if (has_min) {
610 min_value = has_min->intValue();
611 }
612
613 uint32_t max_value = 0;
614 ConstElementPtr has_max = getConfiguredGlobal("max-" + name);
615 bool new_max = true;
616 if (!has_max) {
617 has_max = target_config.getConfiguredGlobal("max-" + name);
618 new_max = false;
619 }
620 if (has_max) {
621 max_value = has_max->intValue();
622 }
623
624 if (!has_value && !has_min && !has_max) {
625 return;
626 }
627 if (has_value) {
628 if (!has_min && !has_max) {
629 // default only.
630 return;
631 } else if (!has_min) {
632 // default and max.
633 min_value = value;
634 } else if (!has_max) {
635 // default and min.
636 max_value = value;
637 }
638 } else if (has_min) {
639 if (!has_max) {
640 // min only.
641 return;
642 } else {
643 // min and max.
644 isc_throw(BadValue, "have min-" << name << " and max-"
645 << name << " but no " << name << " (default)");
646 }
647 } else {
648 // max only.
649 return;
650 }
651
652 // Check that min <= max.
653 if (min_value > max_value) {
654 if (has_min && has_max) {
655 std::string from_min = (new_min ? "new" : "previous");
656 std::string from_max = (new_max ? "new" : "previous");
657 isc_throw(BadValue, "the value of " << from_min
658 << " min-" << name << " ("
659 << min_value << ") is not less than "
660 << from_max << " max-" << name
661 << " (" << max_value << ")");
662 } else if (has_min) {
663 // Only min and default so min > default.
664 std::string from_min = (new_min ? "new" : "previous");
665 std::string from_value = (new_value ? "new" : "previous");
666 isc_throw(BadValue, "the value of " << from_min
667 << " min-" << name << " ("
668 << min_value << ") is not less than " << from_value
669 << " (default) " << name
670 << " (" << value << ")");
671 } else {
672 // Only default and max so default > max.
673 std::string from_max = (new_max ? "new" : "previous");
674 std::string from_value = (new_value ? "new" : "previous");
675 isc_throw(BadValue, "the value of " << from_value
676 << " (default) " << name
677 << " (" << value << ") is not less than " << from_max
678 << " max-" << name << " (" << max_value << ")");
679 }
680 }
681
682 // Check that value is between min and max.
683 if ((value < min_value) || (value > max_value)) {
684 std::string from_value = (new_value ? "new" : "previous");
685 std::string from_min = (new_min ? "new" : "previous");
686 std::string from_max = (new_max ? "new" : "previous");
687 isc_throw(BadValue, "the value of " << from_value
688 <<" (default) " << name << " ("
689 << value << ") is not between " << from_min
690 << " min-" << name << " (" << min_value
691 << ") and " << from_max << " max-"
692 << name << " (" << max_value << ")");
693 }
694}
695
698 // Top level map
700
701 // Get family for the configuration manager
702 uint16_t family = CfgMgr::instance().getFamily();
703
704 // DhcpX global map initialized from configured globals
705 ElementPtr dhcp = configured_globals_->toElement();
706
707 auto loggers_info = getLoggingInfo();
708 // Was in the Logging global map.
709 if (!loggers_info.empty()) {
710 // Set loggers list
712 for (LoggingInfoStorage::const_iterator logger =
713 loggers_info.cbegin();
714 logger != loggers_info.cend(); ++logger) {
715 loggers->add(logger->toElement());
716 }
717 dhcp->set("loggers", loggers);
718 }
719
720 // Set user-context
722
723 // Set compatibility flags.
724 ElementPtr compatibility = Element::createMap();
726 compatibility->set("lenient-option-parsing", Element::create(true));
727 }
729 compatibility->set("ignore-dhcp-server-identifier", Element::create(true));
730 }
732 compatibility->set("ignore-rai-link-selection", Element::create(true));
733 }
734 if (getExcludeFirstLast24()) {
735 compatibility->set("exclude-first-last-24", Element::create(true));
736 }
737 if (compatibility->size() > 0) {
738 dhcp->set("compatibility", compatibility);
739 }
740
741 // Set decline-probation-period
742 dhcp->set("decline-probation-period",
743 Element::create(static_cast<long long>(decline_timer_)));
744 // Set echo-client-id (DHCPv4)
745 if (family == AF_INET) {
746 dhcp->set("echo-client-id", Element::create(echo_v4_client_id_));
747 }
748 // Set dhcp4o6-port
749 dhcp->set("dhcp4o6-port",
750 Element::create(static_cast<int>(dhcp4o6_port_)));
751 // Set dhcp-ddns
752 dhcp->set("dhcp-ddns", d2_client_config_->toElement());
753 // Set interfaces-config
754 dhcp->set("interfaces-config", cfg_iface_->toElement());
755 // Set option-def
756 dhcp->set("option-def", cfg_option_def_->toElement());
757 // Set option-data
758 dhcp->set("option-data", cfg_option_->toElement());
759
760 // Set subnets and shared networks.
761
762 // We have two problems to solve:
763 // - a subnet is unparsed once:
764 // * if it is a plain subnet in the global subnet list
765 // * if it is a member of a shared network in the shared network
766 // subnet list
767 // - unparsed subnets must be kept to add host reservations in them.
768 // Of course this can be done only when subnets are unparsed.
769
770 // The list of all unparsed subnets
771 std::vector<ElementPtr> sn_list;
772
773 if (family == AF_INET) {
774 // Get plain subnets
775 ElementPtr plain_subnets = Element::createList();
776 const Subnet4Collection* subnets = cfg_subnets4_->getAll();
777 for (auto const& subnet : *subnets) {
778 // Skip subnets which are in a shared-network
779 SharedNetwork4Ptr network;
780 subnet->getSharedNetwork(network);
781 if (network) {
782 continue;
783 }
784 ElementPtr subnet_cfg = subnet->toElement();
785 sn_list.push_back(subnet_cfg);
786 plain_subnets->add(subnet_cfg);
787 }
788 dhcp->set("subnet4", plain_subnets);
789
790 // Get shared networks
791 ElementPtr shared_networks = cfg_shared_networks4_->toElement();
792 dhcp->set("shared-networks", shared_networks);
793
794 // Get subnets in shared network subnet lists
795 const std::vector<ElementPtr> networks = shared_networks->listValue();
796 for (auto const& network : networks) {
797 const std::vector<ElementPtr> sh_list =
798 network->get("subnet4")->listValue();
799 for (auto const& subnet : sh_list) {
800 sn_list.push_back(subnet);
801 }
802 }
803
804 } else {
805 // Get plain subnets
806 ElementPtr plain_subnets = Element::createList();
807 const Subnet6Collection* subnets = cfg_subnets6_->getAll();
808 for (auto const& subnet : *subnets) {
809 // Skip subnets which are in a shared-network
810 SharedNetwork6Ptr network;
811 subnet->getSharedNetwork(network);
812 if (network) {
813 continue;
814 }
815 ElementPtr subnet_cfg = subnet->toElement();
816 sn_list.push_back(subnet_cfg);
817 plain_subnets->add(subnet_cfg);
818 }
819 dhcp->set("subnet6", plain_subnets);
820
821 // Get shared networks
822 ElementPtr shared_networks = cfg_shared_networks6_->toElement();
823 dhcp->set("shared-networks", shared_networks);
824
825 // Get subnets in shared network subnet lists
826 const std::vector<ElementPtr> networks = shared_networks->listValue();
827 for (auto const& network : networks) {
828 const std::vector<ElementPtr> sh_list =
829 network->get("subnet6")->listValue();
830 for (auto const& subnet : sh_list) {
831 sn_list.push_back(subnet);
832 }
833 }
834 }
835
836 // Host reservations
837 CfgHostsList resv_list;
838 resv_list.internalize(cfg_hosts_->toElement());
839
840 // Insert global reservations
841 ConstElementPtr global_resvs = resv_list.get(SUBNET_ID_GLOBAL);
842 if (global_resvs->size() > 0) {
843 dhcp->set("reservations", global_resvs);
844 }
845
846 // Insert subnet reservations
847 for (auto const& subnet : sn_list) {
848 ConstElementPtr id = subnet->get("id");
849 if (isNull(id)) {
850 isc_throw(ToElementError, "subnet has no id");
851 }
852 SubnetID subnet_id = id->intValue();
853 ConstElementPtr resvs = resv_list.get(subnet_id);
854 subnet->set("reservations", resvs);
855 }
856
857 // Set expired-leases-processing
858 ConstElementPtr expired = cfg_expiration_->toElement();
859 dhcp->set("expired-leases-processing", expired);
860 if (family == AF_INET6) {
861 // Set server-id (DHCPv6)
862 dhcp->set("server-id", cfg_duid_->toElement());
863
864 // Set relay-supplied-options (DHCPv6)
865 dhcp->set("relay-supplied-options", cfg_rsoo_->toElement());
866 }
867 // Set lease-database
868 CfgLeaseDbAccess lease_db(*cfg_db_access_);
869 dhcp->set("lease-database", lease_db.toElement());
870 // Set hosts-databases
871 CfgHostDbAccess host_db(*cfg_db_access_);
872 ConstElementPtr hosts_databases = host_db.toElement();
873 if (hosts_databases->size() > 0) {
874 dhcp->set("hosts-databases", hosts_databases);
875 }
876 // Set host-reservation-identifiers
877 ConstElementPtr host_ids;
878 if (family == AF_INET) {
879 host_ids = cfg_host_operations4_->toElement();
880 } else {
881 host_ids = cfg_host_operations6_->toElement();
882 }
883 dhcp->set("host-reservation-identifiers", host_ids);
884 // Set mac-sources (DHCPv6)
885 if (family == AF_INET6) {
886 dhcp->set("mac-sources", cfg_mac_source_.toElement());
887 }
888 // Set control-sockets.
889 ElementPtr control_sockets = Element::createList();
890 if (!isNull(unix_control_socket_)) {
891 for (auto const& socket : unix_control_socket_->listValue()) {
892 control_sockets->add(UserContext::toElement(socket));
893 }
894 }
895 if (!isNull(http_control_socket_)) {
896 for (auto const& socket : http_control_socket_->listValue()) {
897 control_sockets->add(UserContext::toElement(socket));
898 }
899 }
900 if (!control_sockets->empty()) {
901 dhcp->set("control-sockets", control_sockets);
902 }
903 // Set client-classes
904 ConstElementPtr client_classes = class_dictionary_->toElement();
906 if (!client_classes->empty()) {
907 dhcp->set("client-classes", client_classes);
908 }
909 // Set hooks-libraries
910 ConstElementPtr hooks_libs = hooks_config_.toElement();
911 dhcp->set("hooks-libraries", hooks_libs);
912 // Set DhcpX
913 result->set(family == AF_INET ? "Dhcp4" : "Dhcp6", dhcp);
914
915 ConstElementPtr cfg_consist = cfg_consist_->toElement();
916 dhcp->set("sanity-checks", cfg_consist);
917
918 // Set config-control (if it exists)
920 if (info) {
921 ConstElementPtr info_elem = info->toElement();
922 dhcp->set("config-control", info_elem);
923 }
924
925 // Set dhcp-packet-control (if it exists)
926 data::ConstElementPtr dhcp_queue_control = getDHCPQueueControl();
927 if (dhcp_queue_control) {
928 dhcp->set("dhcp-queue-control", dhcp_queue_control);
929 }
930
931 // Set multi-threading (if it exists)
932 data::ConstElementPtr dhcp_multi_threading = getDHCPMultiThreading();
933 if (dhcp_multi_threading) {
934 dhcp->set("multi-threading", dhcp_multi_threading);
935 }
936
937 return (result);
938}
939
942 return (DdnsParamsPtr(new DdnsParams(subnet,
943 getD2ClientConfig()->getEnableUpdates())));
944}
945
948 return (DdnsParamsPtr(new DdnsParams(subnet,
949 getD2ClientConfig()->getEnableUpdates())));
950}
951
952void
954 if (!getCfgDbAccess()->getIPReservationsUnique() && unique) {
956 }
957 getCfgHosts()->setIPReservationsUnique(unique);
958 getCfgDbAccess()->setIPReservationsUnique(unique);
959}
960
961void
963 Option::lenient_parsing_ = lenient_option_parsing_;
964}
965
966bool
968 if (!subnet_) {
969 return (false);
970 }
971
972 if (pool_) {
973 auto optional = pool_->getDdnsSendUpdates();
974 if (!optional.unspecified()) {
975 return (optional.get());
976 }
977 }
978
979 return (d2_client_enabled_ && subnet_->getDdnsSendUpdates().get());
980}
981
982bool
984 if (!subnet_) {
985 return (false);
986 }
987
988 if (pool_) {
989 auto optional = pool_->getDdnsOverrideNoUpdate();
990 if (!optional.unspecified()) {
991 return (optional.get());
992 }
993 }
994
995 return (subnet_->getDdnsOverrideNoUpdate().get());
996}
997
999 if (!subnet_) {
1000 return (false);
1001 }
1002
1003 if (pool_) {
1004 auto optional = pool_->getDdnsOverrideClientUpdate();
1005 if (!optional.unspecified()) {
1006 return (optional.get());
1007 }
1008 }
1009
1010 return (subnet_->getDdnsOverrideClientUpdate().get());
1011}
1012
1015 if (!subnet_) {
1017 }
1018
1019 if (pool_) {
1020 auto optional = pool_->getDdnsReplaceClientNameMode();
1021 if (!optional.unspecified()) {
1022 return (optional.get());
1023 }
1024 }
1025
1026 return (subnet_->getDdnsReplaceClientNameMode().get());
1027}
1028
1029std::string
1031 if (!subnet_) {
1032 return ("");
1033 }
1034
1035 if (pool_) {
1036 auto optional = pool_->getDdnsGeneratedPrefix();
1037 if (!optional.unspecified()) {
1038 return (optional.get());
1039 }
1040 }
1041
1042 return (subnet_->getDdnsGeneratedPrefix().get());
1043}
1044
1045std::string
1047 if (!subnet_) {
1048 return ("");
1049 }
1050
1051 if (pool_) {
1052 auto optional = pool_->getDdnsQualifyingSuffix();
1053 if (!optional.unspecified()) {
1054 return (optional.get());
1055 }
1056 }
1057
1058 return (subnet_->getDdnsQualifyingSuffix().get());
1059}
1060
1061std::string
1063 if (!subnet_) {
1064 return ("");
1065 }
1066
1067 return (subnet_->getHostnameCharSet().get());
1068}
1069
1070std::string
1072 if (!subnet_) {
1073 return ("");
1074 }
1075
1076 return (subnet_->getHostnameCharReplacement().get());
1077}
1078
1082 if (subnet_) {
1083 std::string char_set = getHostnameCharSet();
1084 if (!char_set.empty()) {
1085 try {
1086 sanitizer.reset(new util::str::StringSanitizer(char_set,
1088 } catch (const std::exception& ex) {
1089 isc_throw(BadValue, "hostname_char_set_: '" << char_set <<
1090 "' is not a valid regular expression");
1091 }
1092 }
1093 }
1094
1095 return (sanitizer);
1096}
1097
1098void
1100 // Need to check that global DDNS TTL values make sense
1101
1102 // Get ddns-ttl first. If ddns-ttl is specified none of the others should be.
1103 ConstElementPtr has_ddns_ttl = getConfiguredGlobal("ddns-ttl");
1104
1105 if (getConfiguredGlobal("ddns-ttl-percent")) {
1106 if (has_ddns_ttl) {
1107 isc_throw(BadValue, "cannot specify both ddns-ttl-percent and ddns-ttl");
1108 }
1109 }
1110
1111 ConstElementPtr has_ddns_ttl_min = getConfiguredGlobal("ddns-ttl-min");
1112 if (has_ddns_ttl_min && has_ddns_ttl) {
1113 isc_throw(BadValue, "cannot specify both ddns-ttl-min and ddns-ttl");
1114 }
1115
1116 ConstElementPtr has_ddns_ttl_max = getConfiguredGlobal("ddns-ttl-max");
1117 if (has_ddns_ttl_max) {
1118 if (has_ddns_ttl) {
1119 isc_throw(BadValue, "cannot specify both ddns-ttl-max and ddns-ttl");
1120 }
1121
1122 if (has_ddns_ttl_min) {
1123 // Have min and max, make sure the range is sane.
1124 uint32_t ddns_ttl_min = has_ddns_ttl_min->intValue();
1125 uint32_t ddns_ttl_max = has_ddns_ttl_max->intValue();
1126 if (ddns_ttl_max < ddns_ttl_min) {
1127 isc_throw(BadValue, "ddns-ttl-max: " << ddns_ttl_max
1128 << " must be greater than ddns-ttl-min: " << ddns_ttl_min);
1129 }
1130 }
1131 }
1132}
1133
1134} // namespace dhcp
1135} // namespace isc
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.
Cannot unparse error.
static ElementPtr create(const Position &pos=ZERO_POSITION())
Definition data.cc:249
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
Definition data.cc:304
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
Definition data.cc:299
Notes: IntElement type is changed to int64_t.
Definition data.h:615
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).
Definition cfg_duid.h:30
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.
Definition cfg_globals.h:25
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.
Definition cfg_hosts.h:41
Represents selection of interfaces for DHCP server.
Definition cfg_iface.h:131
uint16_t getFamily() const
Returns address family.
Definition cfgmgr.h:246
static CfgMgr & instance()
returns a single instance of Configuration Manager
Definition cfgmgr.cc:29
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.
Definition cfg_option.h:372
Represents configuration of the RSOO options for the DHCP server.
Definition cfg_rsoo.h:25
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...
Definition ddns_params.h:23
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.
Definition option.h:490
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.
Definition srv_config.h:50
ClientClassDictionaryPtr getClientClassDictionary()
Returns pointer to the dictionary of global client class definitions.
Definition srv_config.h:459
static const uint32_t CFGSEL_SUBNET4
Number of IPv4 subnets.
Definition srv_config.h:58
void setDhcp4o6Port(uint16_t port)
Sets DHCP4o6 IPC port.
Definition srv_config.h:696
void addConfiguredGlobal(const std::string &name, isc::data::ConstElementPtr value)
Adds a parameter to the collection configured globals.
Definition srv_config.h:802
CfgGlobalsPtr getConfiguredGlobals()
Returns non-const pointer to configured global parameters.
Definition srv_config.h:736
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.
Definition srv_config.h:474
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.
Definition srv_config.h:755
CfgSharedNetworks6Ptr getCfgSharedNetworks6() const
Returns pointer to non-const object holding configuration of shared networks in DHCPv6.
Definition srv_config.h:216
bool getIgnoreRAILinkSelection() const
Get ignore RAI Link Selection compatibility flag.
Definition srv_config.h:904
void setD2ClientConfig(const D2ClientConfigPtr &d2_client_config)
Sets the D2 client configuration.
Definition srv_config.h:726
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.
Definition srv_config.h:300
bool sequenceEquals(const SrvConfig &other)
Compares configuration sequence with other sequence.
CfgSubnets4Ptr getCfgSubnets4()
Returns pointer to non-const object holding subnets configuration for DHCPv4.
Definition srv_config.h:198
CfgSubnets6Ptr getCfgSubnets6()
Returns pointer to non-const object holding subnets configuration for DHCPv6.
Definition srv_config.h:232
CfgOptionDefPtr getCfgOptionDef()
Return pointer to non-const object representing user-defined option definitions.
Definition srv_config.h:159
D2ClientConfigPtr getD2ClientConfig()
Returns pointer to the D2 client configuration.
Definition srv_config.h:712
void setReservationsLookupFirst(const bool first)
Sets whether the server does host reservations lookup before lease lookup.
Definition srv_config.h:845
const isc::data::ConstElementPtr getDHCPMultiThreading() const
Returns DHCP multi threading information.
Definition srv_config.h:444
void setDHCPQueueControl(const isc::data::ConstElementPtr dhcp_queue_control)
Sets information about the dhcp queue control.
Definition srv_config.h:437
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.
Definition srv_config.cc:86
const isc::data::ConstElementPtr getDHCPQueueControl() const
Returns DHCP queue control information.
Definition srv_config.h:430
bool equals(const SrvConfig &other) const
Compares two objects for equality.
uint32_t getSequence() const
Returns configuration sequence number.
Definition srv_config.h:116
static const uint32_t CFGSEL_DDNS
DDNS enabled/disabled.
Definition srv_config.h:66
void setDeclinePeriod(const uint32_t decline_timer)
Sets decline probation-period.
Definition srv_config.h:660
void removeStatistics()
Removes statistics.
CfgExpirationPtr getCfgExpiration()
Returns pointer to the object holding configuration pertaining to processing expired leases.
Definition srv_config.h:282
CfgOptionPtr getCfgOption()
Returns pointer to the non-const object holding options.
Definition srv_config.h:180
virtual isc::data::ElementPtr toElement() const
Unparse a configuration object.
bool getLenientOptionParsing() const
Get lenient option parsing compatibility flag.
Definition srv_config.h:874
static const uint32_t CFGSEL_SUBNET6
Number of IPv6 subnets.
Definition srv_config.h:60
bool getExcludeFirstLast24() const
Get exclude .0 and .255 addresses in subnets bigger than /24 flag.
Definition srv_config.h:919
void updateStatistics()
Updates statistics.
CfgDbAccessPtr getCfgDbAccess()
Returns pointer to the object holding configuration of the lease and host database connection paramet...
Definition srv_config.h:318
void setEchoClientId(const bool echo)
Sets whether server should send back client-id in DHCPv4.
Definition srv_config.h:679
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;.
Definition srv_config.h:207
CfgHostsPtr getCfgHosts()
Returns pointer to the non-const objects representing host reservations for different IPv4 and IPv6 s...
Definition srv_config.h:248
bool getIgnoreServerIdentifier() const
Get ignore DHCP Server Identifier compatibility flag.
Definition srv_config.h:889
SrvConfig()
Default constructor.
Definition srv_config.cc:45
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.
Definition config_base.h:33
process::ConstConfigControlInfoPtr getConfigControlInfo() const
Fetches a read-only copy of the configuration control information.
const process::LoggingInfoStorage & getLoggingInfo() const
Returns logging specific configuration.
Definition config_base.h:43
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.
Definition str.h:222
#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.
Definition macros.h:26
boost::shared_ptr< const Element > ConstElementPtr
Definition data.h:29
bool isNull(ConstElementPtr p)
Checks whether the given ElementPtr is a NULL pointer.
Definition data.cc:1148
std::vector< SimpleDefault > SimpleDefaults
This specifies all default values in a given scope (e.g. a subnet).
boost::shared_ptr< Element > ElementPtr
Definition data.h:28
@ info
Definition db_log.h:120
isc::log::Logger dhcpsrv_logger("dhcpsrv")
DHCP server library Logger.
Definition dhcpsrv_log.h:56
boost::shared_ptr< CfgDUID > CfgDUIDPtr
Pointer to the Non-const object.
Definition cfg_duid.h:161
boost::shared_ptr< D2ClientConfig > D2ClientConfigPtr
Defines a pointer for D2ClientConfig instances.
boost::shared_ptr< const Subnet6 > ConstSubnet6Ptr
A const pointer to a Subnet6 object.
Definition subnet.h:623
boost::shared_ptr< const Subnet4 > ConstSubnet4Ptr
A const pointer to a Subnet4 object.
Definition subnet.h:458
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.
Definition subnet.h:937
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.
Definition subnet.h:866
uint32_t SubnetID
Defines unique IPv4 or IPv6 subnet identifier.
Definition subnet_id.h:25
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.
Definition str.h:263
Defines the logger used by the top-level component of kea-lfc.
Represents the position of the data element within a configuration string.
Definition data.h:94
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.