16const string DHCP4_SPACE =
"dhcp4";
17const string DHCP6_SPACE =
"dhcp6";
33 if (!subnets || subnets->empty()) {
54 const string& subsel) {
55 if (!networks || networks->empty()) {
65 for (
size_t i = 0; i < networks->size(); ++i) {
69 if (!subnets->empty()) {
77 network->remove(subsel);
87 if (!subnets || subnets->empty()) {
92 for (
size_t i = 0; i < subnets->size(); ++i) {
101 const string& subsel) {
102 if (!networks || networks->empty()) {
109 if (!subnets || subnets->empty()) {
113 for (
size_t i = 0; i < subnets->size(); ++i) {
122 if (!pools || pools->empty()) {
129 for (
size_t i = 0; i < pools->size(); ++i) {
137 if (!subnets || subnets->empty()) {
149 const string& subsel) {
150 if (!networks || networks->empty()) {
164 if (!defs || defs->empty()) {
171 for (
size_t i = 0; i < defs->size(); ++i) {
184 if (!options || options->empty()) {
191 for (
size_t i = 0; i < options->size(); ++i) {
202 if (!classes || classes->empty()) {
208 for (
size_t i = 0; i < classes->size(); ++i) {
211 if (space == DHCP4_SPACE) {
214 if (!options->empty()) {
219 cclass->remove(
"option-def");
227 if (!options->empty()) {
232 cclass->remove(
"option-data");
241 if (!pools || pools->empty()) {
246 for (
size_t i = 0; i < pools->size(); ++i) {
250 if (!options->empty()) {
253 pool->remove(
"option-data");
262 if (!hosts || hosts->empty()) {
267 for (
size_t i = 0; i < hosts->size(); ++i) {
271 if (!options->empty()) {
274 host->remove(
"option-data");
284 if (!subnets || subnets->empty()) {
289 for (
size_t i = 0; i < subnets->size(); ++i) {
295 if (!options->empty()) {
298 subnet->remove(
"option-data");
305 if (!pools->empty()) {
308 subnet->remove(
"pools");
313 if (space == DHCP6_SPACE) {
316 if (!pools->empty()) {
319 subnet->remove(
"pd-pools");
327 if (!hosts->empty()) {
330 subnet->remove(
"reservations");
340 if (!networks || networks->empty()) {
346 for (
size_t i = 0; i < networks->size(); ++i) {
347 ElementPtr network = networks->getNonConst(i);
352 if (!options->empty()) {
355 network->remove(
"option-data");
358 string subnet =
"subnet";
359 if (space == DHCP4_SPACE) {
368 if (!subnets->empty()) {
371 network->remove(subnet);
379 if (!pools || pools->empty()) {
384 for (
size_t i = 0; i < pools->size(); ++i) {
387 if (
requires && requires->empty()) {
388 pool->remove(
"require-client-classes");
395 if (!subnets || subnets->empty()) {
400 for (
size_t i = 0; i < subnets->size(); ++i) {
405 if (
requires && requires->empty()) {
406 subnet->remove(
"require-client-classes");
413 const string& subsel) {
414 if (!networks || networks->empty()) {
419 for (
size_t i = 0; i < networks->size(); ++i) {
420 ElementPtr network = networks->getNonConst(i);
423 if (
requires && requires->empty()) {
424 network->remove(
"require-client-classes");
432 if (!hosts || hosts->empty()) {
437 for (
size_t i = 0; i < hosts->size(); ++i) {
446 if (!subnets || subnets->empty()) {
458 const string& space) {
459 if (!networks || networks->empty()) {
465 if (space == DHCP4_SPACE) {
475 if (!subnets || subnets->empty()) {
480 for (
size_t i = 0; i < subnets->size(); ++i) {
488 const string& subsel) {
489 if (!networks || networks->empty()) {
494 for (
size_t i = 0; i < networks->size(); ++i) {
495 ElementPtr network = networks->getNonConst(i);
509 ElementPtr mutable_dhcp = boost::const_pointer_cast<Element>(dhcp);
510 mutable_dhcp->remove(
"hosts-database");
512 list->add(boost::const_pointer_cast<Element>(database));
513 mutable_dhcp->set(
"hosts-databases", list);
519 if (!options || !options->empty()) {
523 ElementPtr mutable_dhcp = boost::const_pointer_cast<Element>(dhcp);
524 mutable_dhcp->remove(
"relay-supplied-options");
529 const string& space) {
533 bool have_ids =
true;
537 if (!subnets->empty()) {
542 dhcp->remove(subsel);
547 if (!networks->empty()) {
552 dhcp->remove(
"shared-networks");
566 if (!defs->empty()) {
569 dhcp->remove(
"option-def");
574 if (!options->empty()) {
577 dhcp->remove(
"option-data");
582 if (!classes->empty()) {
585 dhcp->remove(
"client-classes");
590 if (!hosts->empty()) {
594 dhcp->remove(
"reservations");
614 if (space == DHCP6_SPACE) {
624 if (config->getType() != Element::map) {
627 if (config->contains(
"Logging")) {
634 ElementPtr mutable_dhcp = boost::const_pointer_cast<Element>(dhcp);
635 preProcess(mutable_dhcp,
"subnet4", DHCP4_SPACE);
643 if (config->getType() != Element::map) {
646 if (config->contains(
"Logging")) {
653 ElementPtr mutable_dhcp = boost::const_pointer_cast<Element>(dhcp);
654 preProcess(mutable_dhcp,
"subnet6", DHCP6_SPACE);
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
static void sanitizeRequireClassesPools(isc::data::ConstElementPtr pools)
Process require client classes in a pool list.
static void sanitizeOptionSharedNetworks(isc::data::ConstElementPtr networks, const std::string &space, const OptionCodes &codes)
Set missing option codes to a shared network list.
static void subnetsAssignID(isc::data::ConstElementPtr subnets, SubnetIDSet &set, isc::dhcp::SubnetID &next)
Assigns subnet-id to every subnet in a subnet list.
static void sanitizeRelaySubnets(isc::data::ConstElementPtr subnets)
Sanitizes relay information in subnets in a subnet list.
static void sanitizeHostSubnets(isc::data::ConstElementPtr subnets)
Process host reservations in a subnet list.
AdaptorConfig()
Constructor.
static void sanitizeOptionPools(isc::data::ConstElementPtr pools, const std::string &space, const OptionCodes &codes)
Set missing option codes to a pool list.
static void sanitizeDatabase(isc::data::ConstElementPtr dhcp)
Update (hosts) database.
static void preProcess(isc::data::ElementPtr dhcp, const std::string &subsel, const std::string &space)
Pre process a configuration.
static void sharedNetworksAssignID(isc::data::ConstElementPtr networks, SubnetIDSet &set, isc::dhcp::SubnetID &next, const std::string &subsel)
Assigns subnet-id to every subnet in a shared network list.
static void sanitizePoolsInSubnets(isc::data::ConstElementPtr subnets)
Sanitizes all pools in a subnets list.
static void requireClassesSharedNetworks(isc::data::ConstElementPtr networks, const std::string &subsel)
Process require client classes in a shared network list.
static void preProcess4(isc::data::ConstElementPtr config)
Pre process a DHCPv4 configuration.
static bool subnetsCollectID(isc::data::ConstElementPtr subnets, SubnetIDSet &set)
Collects subnet-ids on all subnets.
static void sanitizeOptionHosts(isc::data::ConstElementPtr hosts, const std::string &space, const OptionCodes &codes)
Set missing option codes to a host reservation list.
static void sanitizeHostList(isc::data::ConstElementPtr hosts)
Process host reservation list.
static void SanitizeHostsInSharedNetworks(isc::data::ConstElementPtr networks, const std::string &space)
Process host reservations in a shared network list.
static void sanitizeOptionDefList(isc::data::ConstElementPtr defs, const std::string &space, OptionCodes &codes)
Collect option definitions from an option definition list.
virtual ~AdaptorConfig()
Destructor.
static void sanitizeRequireClassesSubnets(isc::data::ConstElementPtr subnets)
Process require client classes in a subnet list.
static void sanitizeOptionSubnets(isc::data::ConstElementPtr subnets, const std::string &space, const OptionCodes &codes)
Set missing option codes to a subnet list.
static void sanitizePools(isc::data::ConstElementPtr pools)
Sanitizes all pools in a pools list.
static void sanitizePoolsInSharedNetworks(isc::data::ConstElementPtr networks, const std::string &subsel)
Sanitizes all pools in all subnets in a shared network list.
static void sanitizeOptionClasses(isc::data::ConstElementPtr classes, const std::string &space, OptionCodes &codes)
Collect option definitions from a client class list and set missing option codes.
static bool sharedNetworksCollectID(isc::data::ConstElementPtr networks, SubnetIDSet &set, const std::string &subsel)
Collects subnet-ids in all subnets in all shared network list.
static void sanitizeRelaySuppliedOptions(isc::data::ConstElementPtr dhcp)
Update relay supplied options.
static void preProcess6(isc::data::ConstElementPtr config)
Pre process a DHCPv6 configuration.
static void sanitizeOptionDataList(isc::data::ConstElementPtr options, const std::string &space, const OptionCodes &codes)
Set missing option codes to an option data list.
static void sanitizeRelayInSharedNetworks(isc::data::ConstElementPtr networks, const std::string &subsel)
Sanitizes relay information in a shared network list.
static void quoteIdentifier(isc::data::ElementPtr host)
Quote when needed a host identifier.
static void setCode(isc::data::ElementPtr option, const OptionCodes &codes)
Set code from name and definitions.
static void initCodes(OptionCodes &codes, const std::string &space)
Initialize code map.
static void setSpace(isc::data::ElementPtr option, const std::string &space)
Set space.
static void checkType(isc::data::ConstElementPtr option)
Checks if type is specified in option definition.
static void collect(isc::data::ConstElementPtr option, OptionCodes &codes)
Collect definition.
static void checkCode(isc::data::ConstElementPtr option)
Check if code is specified in option defintion.
static void canonizePool(isc::data::ElementPtr pool)
Canonize pool.
static bool collectID(isc::data::ConstElementPtr subnet, SubnetIDSet &set)
Collect a subnet ID.
static void updateRelay(isc::data::ElementPtr subnet)
Update relay.
static void assignID(isc::data::ElementPtr subnet, SubnetIDSet &set, isc::dhcp::SubnetID &next)
Assign subnet ID.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< Element > ElementPtr
uint32_t SubnetID
Defines unique IPv4 or IPv6 subnet identifier.
std::set< isc::dhcp::SubnetID > SubnetIDSet
Set of SubnetIDs.
std::map< std::string, uint16_t > OptionCodes
Map for DHCP option definitions handling code and an index built from space and name.
Defines the logger used by the top-level component of kea-lfc.