18#include <boost/make_shared.hpp> 
   19#include <boost/pointer_cast.hpp> 
   25namespace ph = std::placeholders;
 
   36                            bool encapsulate_options) {
 
   46        std::string name = 
getString(shared_network_data, 
"name");
 
   50        mutable_params = boost::const_pointer_cast<Element>(shared_network_data);
 
   53        NetworkPtr network = boost::dynamic_pointer_cast<Network>(shared_network);
 
   57        if (shared_network_data->contains(
"interface")) {
 
   58            std::string iface = 
getString(shared_network_data, 
"interface");
 
   62                        shared_network_data->get(
"interface");
 
   64                              "Specified network interface name " << iface
 
   65                              << 
" for shared network " << name
 
   66                              << 
" is not present in the system (" 
   67                              << 
error->getPosition() << 
")");
 
   69                shared_network->setIface(iface);
 
   73        if (shared_network_data->contains(
"option-data")) {
 
   74            auto json = shared_network_data->get(
"option-data");
 
   76            CfgOptionPtr cfg_option = shared_network->getCfgOption();
 
   78            parser->parse(cfg_option, json, encapsulate_options);
 
   81        if (shared_network_data->contains(
"subnet4")) {
 
   82            auto json = shared_network_data->get(
"subnet4");
 
   87            parser->parse(subnets, json);
 
   90            for (
auto const& subnet : subnets) {
 
   91                shared_network->add(subnet);
 
   95        if (shared_network_data->contains(
"match-client-id")) {
 
   96            shared_network->setMatchClientId(
getBoolean(shared_network_data,
 
  100        if (shared_network_data->contains(
"authoritative")) {
 
  101            shared_network->setAuthoritative(
getBoolean(shared_network_data,
 
  106        if (shared_network_data->contains(
"next-server")) {
 
  107            std::string next_server;
 
  109                next_server = 
getString(shared_network_data, 
"next-server");
 
  110                if (!next_server.empty()) {
 
  111                    shared_network->setSiaddr(
IOAddress(next_server));
 
  117                    pos = next->getPosition().str();
 
  119                    pos = shared_network_data->getPosition().str();
 
  122                          << next_server << 
"(" << pos << 
")");
 
  127        if (shared_network_data->contains(
"server-hostname")) {
 
  128            std::string sname = 
getString(shared_network_data, 
"server-hostname");
 
  129            if (!sname.empty()) {
 
  134                              << sname.length() << 
" (" 
  135                              << 
error->getPosition() << 
")");
 
  137                shared_network->setSname(sname);
 
  142        if (shared_network_data->contains(
"boot-file-name")) {
 
  143            std::string filename = 
getString(shared_network_data, 
"boot-file-name");
 
  144            if (!filename.empty()) {
 
  149                              << filename.length() << 
" (" 
  150                              << 
error->getPosition() << 
")");
 
  152                shared_network->setFilename(filename);
 
  156        ConstElementPtr user_context = shared_network_data->get(
"user-context");
 
  158            shared_network->setContext(user_context);
 
  164                                       boost::dynamic_pointer_cast<Network>(shared_network), ph::_1));
 
  169                                           boost::dynamic_pointer_cast<Network>(shared_network), ph::_1));
 
  171        if (shared_network_data->contains(
"relay")) {
 
  172            auto relay_parms = shared_network_data->get(
"relay");
 
  176                parser.
parse(relay_info, relay_parms);
 
  177                shared_network->setRelayInfo(*relay_info);
 
  193        Network4Ptr network4 = boost::dynamic_pointer_cast<Network4>(shared_network);
 
  196    } 
catch (
const std::exception& ex) {
 
  198                  << shared_network_data->getPosition() << 
")");
 
  208    return (shared_network);
 
 
  211boost::shared_ptr<OptionDataListParser>
 
  213    auto parser = boost::make_shared<OptionDataListParser>(AF_INET);
 
 
  217boost::shared_ptr<Subnets4ListConfigParser>
 
  219    auto parser = boost::make_shared<Subnets4ListConfigParser>(
check_iface_);
 
 
  229                            bool encapsulate_options) {
 
  235                      shared_network_data);
 
  239        name = 
getString(shared_network_data, 
"name");
 
  243        mutable_params = boost::const_pointer_cast<Element>(shared_network_data);
 
  246        NetworkPtr network = boost::dynamic_pointer_cast<Network>(shared_network);
 
  251                                                     "preferred-lifetime"));
 
  256        if (shared_network_data->contains(
"interface-id")) {
 
  257            ifaceid = 
getString(shared_network_data, 
"interface-id");
 
  262        if (shared_network_data->contains(
"interface")) {
 
  263            iface = 
getString(shared_network_data, 
"interface");
 
  272                      "parser error: interface (defined for locally reachable " 
  273                      "subnets) and interface-id (defined for subnets reachable" 
  274                      " via relays) cannot be defined at the same time for " 
  275                      "shared network " << name << 
"(" 
  276                      << shared_network_data->getPosition() << 
")");
 
  281            std::string ifaceid_value = ifaceid.
get();
 
  282            OptionBuffer tmp(ifaceid_value.begin(), ifaceid_value.end());
 
  284            shared_network->setInterfaceId(opt);
 
  293                          "Specified network interface name " << iface
 
  294                          << 
" for shared network " << name
 
  295                          << 
" is not present in the system (" 
  296                          << 
error->getPosition() << 
")");
 
  298            shared_network->setIface(iface);
 
  301        if (shared_network_data->contains(
"rapid-commit")) {
 
  302            shared_network->setRapidCommit(
getBoolean(shared_network_data,
 
  306        if (shared_network_data->contains(
"option-data")) {
 
  307            auto json = shared_network_data->get(
"option-data");
 
  309            CfgOptionPtr cfg_option = shared_network->getCfgOption();
 
  311            parser->parse(cfg_option, json, encapsulate_options);
 
  314        ConstElementPtr user_context = shared_network_data->get(
"user-context");
 
  316            shared_network->setContext(user_context);
 
  322                                       boost::dynamic_pointer_cast<Network>(shared_network), ph::_1));
 
  327                                           boost::dynamic_pointer_cast<Network>(shared_network), ph::_1));
 
  329        if (shared_network_data->contains(
"subnet6")) {
 
  330            auto json = shared_network_data->get(
"subnet6");
 
  335            parser->parse(subnets, json);
 
  338            for (
auto const& subnet : subnets) {
 
  339                shared_network->add(subnet);
 
  343        if (shared_network_data->contains(
"relay")) {
 
  344            auto relay_parms = shared_network_data->get(
"relay");
 
  348                parser.
parse(relay_info, relay_parms);
 
  349                shared_network->setRelayInfo(*relay_info);
 
  363        if (network->getAllocatorType() == 
"flq") {
 
  364            isc_throw(
BadValue, 
"Free Lease Queue allocator is not supported for IPv6 address pools");
 
  368        auto network6 = boost::dynamic_pointer_cast<Network6>(shared_network);
 
  371    } 
catch (
const std::exception& ex) {
 
  373                  << shared_network_data->getPosition() << 
")");
 
  383    return (shared_network);
 
 
  386boost::shared_ptr<OptionDataListParser>
 
  388    auto parser = boost::make_shared<OptionDataListParser>(AF_INET6);
 
 
  392boost::shared_ptr<Subnets6ListConfigParser>
 
  394    auto parser = boost::make_shared<Subnets6ListConfigParser>(
check_iface_);
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
The IOAddress class represents an IP addresses (version agnostic)
static void checkKeywords(const SimpleKeywords &keywords, isc::data::ConstElementPtr scope)
Checks acceptable keywords with their expected type.
static std::string getString(isc::data::ConstElementPtr scope, const std::string &name)
Returns a string parameter from a scope.
const isc::util::Triplet< uint32_t > parseIntTriplet(const data::ConstElementPtr &scope, const std::string &name)
Parses an integer triplet.
static bool getBoolean(isc::data::ConstElementPtr scope, const std::string &name)
Returns a boolean parameter from a scope.
void parseCacheParams(const data::ConstElementPtr &network_data, NetworkPtr &network)
Parses parameters related to lease cache settings.
void parseAllocatorParams(const data::ConstElementPtr &network_data, NetworkPtr &network)
Parses parameters pertaining to allocator selection.
static void getClientClassesElem(data::ConstElementPtr params, ClassAdderFunc adder_func)
Fetches the element for either 'client-classes' or deprecated 'client-class'.
void parseDdnsParams(const data::ConstElementPtr &network_data, NetworkPtr &network)
Parses parameters pertaining to DDNS behavior.
void parseCommon(const data::ConstElementPtr &network_data, NetworkPtr &network)
Parses common parameters.
static void getAdditionalClassesElem(data::ConstElementPtr params, ClassAdderFunc adder_func)
Fetches the element for either 'evaluate-additional-classes' or deprecated 'require-client-classes'.
void parseTeePercents(const data::ConstElementPtr &network_data, NetworkPtr &network)
Parses parameters related to "percent" timers settings.
void parsePdAllocatorParams(const data::ConstElementPtr &network_data, Network6Ptr &network)
Parses parameters pertaining to prefix delegation allocator selection.
void parseOfferLft(const data::ConstElementPtr &network_data, Network4Ptr &network)
Parses offer-lifetime parameter (v4 only)
static CfgMgr & instance()
returns a single instance of Configuration Manager
To be removed. Please use ConfigError instead.
static IfaceMgr & instance()
IfaceMgr is a singleton class.
Holds optional information about relay.
boost::shared_ptr< Network::RelayInfo > RelayInfoPtr
Pointer to the RelayInfo structure.
void allowClientClass(const isc::dhcp::ClientClass &class_name)
Adds class clas_name to the allowed client classes list.
void addAdditionalClass(const isc::dhcp::ClientClass &class_name)
Adds class class_name to the additional classes list.
static const size_t MAX_SNAME_LEN
length of the SNAME field in DHCPv4 message
static const size_t MAX_FILE_LEN
length of the FILE field in DHCPv4 message
parser for additional relay information
void parse(const isc::dhcp::Network::RelayInfoPtr &relay_info, isc::data::ConstElementPtr relay_elem)
parses the actual relay parameters
virtual boost::shared_ptr< Subnets4ListConfigParser > createSubnetsListParser() const
Returns an instance of the Subnets4ListConfigParser to be used for parsing the subnets within the sha...
SharedNetwork4Parser(bool check_iface=true)
Constructor.
virtual boost::shared_ptr< OptionDataListParser > createOptionDataListParser() const
Returns an instance of the OptionDataListParser to be used in parsing the option-data structure.
bool check_iface_
Check if the specified interface exists in the system.
SharedNetwork4Ptr parse(const data::ConstElementPtr &shared_network_data, bool encapsulate_options=true)
Parses shared configuration information for IPv4 shared network.
Shared network holding IPv4 subnets.
SharedNetwork6Parser(bool check_iface=true)
Constructor.
virtual boost::shared_ptr< Subnets6ListConfigParser > createSubnetsListParser() const
Returns an instance of the Subnets6ListConfigParser to be used for parsing the subnets within the sha...
bool check_iface_
Check if the specified interface exists in the system.
virtual boost::shared_ptr< OptionDataListParser > createOptionDataListParser() const
Returns an instance of the OptionDataListParser to be used in parsing the option-data structure.
SharedNetwork6Ptr parse(const data::ConstElementPtr &shared_network_data, bool encapsulate_options=true)
Parses shared configuration information for IPv6 shared network.
Shared network holding IPv6 subnets.
static const isc::data::SimpleKeywords SHARED_NETWORK4_PARAMETERS
This table defines all shared network parameters for DHCPv4.
static const isc::data::SimpleKeywords SHARED_NETWORK6_PARAMETERS
This table defines all shared network parameters for DHCPv6.
A template representing an optional value.
T get() const
Retrieves the encapsulated value.
bool empty() const
Checks if the encapsulated value is empty.
void unspecified(bool unspecified)
Modifies the flag that indicates whether the value is specified or unspecified.
#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
boost::shared_ptr< const CfgGlobals > ConstCfgGlobalsPtr
Const shared pointer to a CfgGlobals instance.
boost::shared_ptr< Network4 > Network4Ptr
Pointer to the Network4 object.
boost::shared_ptr< CfgOption > CfgOptionPtr
Non-const pointer.
boost::multi_index_container< Subnet6Ptr, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetSubnetIdIndexTag >, boost::multi_index::const_mem_fun< Subnet, SubnetID, &Subnet::getID > >, boost::multi_index::ordered_unique< boost::multi_index::tag< SubnetPrefixIndexTag >, boost::multi_index::const_mem_fun< Subnet, std::string, &Subnet::toText > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< SubnetModificationTimeIndexTag >, boost::multi_index::const_mem_fun< data::BaseStampedElement, boost::posix_time::ptime, &data::BaseStampedElement::getModificationTime > > > > Subnet6Collection
A collection of Subnet6 objects.
boost::shared_ptr< 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.
boost::shared_ptr< Network > NetworkPtr
Pointer to the Network object.
std::vector< uint8_t > OptionBuffer
buffer types used in DHCP code.
boost::shared_ptr< SharedNetwork4 > SharedNetwork4Ptr
Pointer to SharedNetwork4 object.
boost::shared_ptr< Option > OptionPtr
Defines the logger used by the top-level component of kea-lfc.