27#include <boost/algorithm/string.hpp> 
   28#include <boost/foreach.hpp> 
   29#include <boost/lexical_cast.hpp> 
   30#include <boost/make_shared.hpp> 
   31#include <boost/scoped_ptr.hpp> 
   44namespace ph = std::placeholders;
 
   60    for (
auto const& source_elem : value->listValue()) {
 
   61        std::string source_str = source_elem->stringValue();
 
   64            mac_sources.
add(source);
 
   68                      << 
"' was specified twice (" << value->getPosition() << 
")");
 
   69        } 
catch (
const std::exception& ex) {
 
   71                      << source_str << 
"' to any recognized MAC source:" 
   72                      << ex.
what() << 
" (" << value->getPosition() << 
")");
 
 
   86                  "Specified control-sockets is expected to be a list");
 
   88    bool seen_unix(
false);
 
   95                      "Specified control-sockets is expected to be a list of maps");
 
  100                      "'socket-type' parameter is mandatory in control-sockets items");
 
  105                      "'socket-type' parameter is expected to be a string");
 
  107        string type = socket_type->stringValue();
 
  108        if (type == 
"unix") {
 
  111                          "control socket of type 'unix' already configured");
 
  115            unix_config->add(socket);
 
  116        } 
else if ((type == 
"http") || (type == 
"https")) {
 
  118            http_config->add(socket);
 
  122                      "unsupported 'socket-type': '" << type
 
  123                      << 
"' not 'unix', 'http' or 'https'");
 
  126    if (unix_config->size()) {
 
  129    if (http_config->size()) {
 
 
  137    : address_family_(address_family) {
 
 
  144    if (address_family_ == AF_INET) {
 
  151    std::string name = 
getString(option_def, 
"name");
 
  152    int64_t code64 = 
getInteger(option_def, 
"code");
 
  153    std::string type = 
getString(option_def, 
"type");
 
  157    bool array_type = 
getBoolean(option_def, 
"array");
 
  158    std::string record_types = 
getString(option_def, 
"record-types");
 
  159    std::string space = 
getString(option_def, 
"space");
 
  160    std::string encapsulates = 
getString(option_def, 
"encapsulate");
 
  167    } 
else if (address_family_ == AF_INET &&
 
  168               code64 > std::numeric_limits<uint8_t>::max()) {
 
  170                  << 
"', it must not be greater than '" 
  171                  << 
static_cast<int>(std::numeric_limits<uint8_t>::max())
 
  172                  << 
"' (" << 
getPosition(
"code", option_def) << 
")");
 
  173    } 
else if (address_family_ == AF_INET6 &&
 
  174               code64 > std::numeric_limits<uint16_t>::max()) {
 
  176                  << 
"', it must not be greater than '" 
  177                  << std::numeric_limits<uint16_t>::max()
 
  178                  << 
"' (" << 
getPosition(
"code", option_def) << 
")");
 
  180    uint32_t code = 
static_cast<uint32_t
>(code64);
 
  194                      << 
"reserved for PAD (" 
  198                      << 
"reserved for END (" 
  207                      << 
"reserved value (" 
  216    if (!encapsulates.empty()) {
 
  220                      << name << 
"', comprising an array of data" 
  221                      << 
" fields may not encapsulate any option space (" 
  222                      << option_def->getPosition() << 
")");
 
  224        } 
else if (encapsulates == space) {
 
  226                      << 
" an option space it belongs to: '" 
  227                      << space << 
"." << name << 
"' is set to" 
  228                      << 
" encapsulate '" << space << 
"' (" 
  229                      << option_def->getPosition() << 
")");
 
  233                      encapsulates.c_str()));
 
  242        def->setContext(user_context);
 
  246    std::vector<std::string> record_tokens =
 
  250    for (
auto const& record_type : record_tokens) {
 
  252            auto const trim_rec = boost::trim_copy(record_type);
 
  253            if (!trim_rec.empty()) {
 
  254                def->addRecordField(trim_rec);
 
  258                      << 
" specified for the option definition: " 
  260                      << 
getPosition(
"record-types", option_def) << 
")");
 
  267    } 
catch (
const std::exception& ex) {
 
  269                  << 
" (" << option_def->getPosition() << 
")");
 
 
  279    : address_family_(address_family) {
 
 
  284    if (!option_def_list) {
 
  287                  << 
" option definitions is NULL (" 
  288                  << option_def_list->getPosition() << 
")");
 
  292    for (
auto const& option_def : option_def_list->listValue()) {
 
  296        } 
catch (
const std::exception& ex) {
 
  299                      << option_def->getPosition() << 
")");
 
 
  331                  "(" << 
getPosition(
"ip-addresses", relay_elem) << 
")");
 
  334    for (
auto const& address_element : addresses->listValue()) {
 
  335        addAddress(
"ip-addresses", address_element->stringValue(),
 
  336                   relay_elem, relay_info);
 
 
  342                            const std::string& address_str,
 
  345    boost::scoped_ptr<isc::asiolink::IOAddress> ip;
 
  348    } 
catch (
const std::exception& ex) {
 
  350                  << 
" is not a valid: " 
  367        relay_info->addAddress(*ip);
 
  368    } 
catch (
const std::exception& ex) {
 
  370                  << 
" to relay info: " << ex.what()
 
 
  380                  const uint16_t address_family,
 
  381                  bool encapsulate_options) {
 
  383    if (address_family == AF_INET) {
 
  393                  "definition: (" << pool_structure->getPosition() << 
")");
 
  399    string txt = text_pool->stringValue();
 
  402    boost::erase_all(txt, 
" "); 
 
  403    boost::erase_all(txt, 
"\t"); 
 
  408    size_t pos = txt.find(
"/");
 
  409    if (pos != string::npos) {
 
  416            string prefix_len = txt.substr(pos + 1);
 
  428            int val_len = boost::lexical_cast<int>(prefix_len);
 
  429            if ((val_len < std::numeric_limits<uint8_t>::min()) ||
 
  430                (val_len > std::numeric_limits<uint8_t>::max())) {
 
  434            len = 
static_cast<uint8_t
>(val_len);
 
  437                      "definition: " << txt << 
" (" 
  438                      << text_pool->getPosition() << 
")");
 
  443            pools->push_back(pool);
 
  444        } 
catch (
const std::exception& ex) {
 
  446                      << txt << 
" (" << text_pool->getPosition() << 
")");
 
  455        if (pos != string::npos) {
 
  462                          "definition: " << txt << 
" (" 
  463                          << text_pool->getPosition() << 
")");
 
  468                pools->push_back(pool);
 
  469            } 
catch (
const std::exception& ex) {
 
  471                          << txt << 
" (" << text_pool->getPosition() << 
")");
 
  478                  << text_pool->stringValue() <<
 
  479                  ". There are two acceptable formats <min address-max address>" 
  481                  << text_pool->getPosition() << 
")");
 
  487        if (pool_id->intValue() <= 0) {
 
  489                      << 
" a positive integer greater than 0");
 
  490        } 
else if (pool_id->intValue() > numeric_limits<uint32_t>::max()) {
 
  492                      << 
" a 32 bit unsigned integer");
 
  495        pool->setID(pool_id->intValue());
 
  504                      << user_context->getPosition() << 
")");
 
  506        pool->setContext(user_context);
 
  515            option_parser->parse(cfg, option_data, encapsulate_options);
 
  516        } 
catch (
const std::exception& ex) {
 
  518                      << 
" (" << option_data->getPosition() << 
")");
 
  525        string cclass = client_class->stringValue();
 
  526        if (!cclass.empty()) {
 
  527            pool->allowClientClass(cclass);
 
 
  546boost::shared_ptr<OptionDataListParser>
 
  548    return (boost::make_shared<OptionDataListParser>(address_family));
 
 
  567                        bool encapsulate_options) {
 
  568    for (
auto const& pool : pools_list->listValue()) {
 
  570        parser->parse(pools, pool, AF_INET, encapsulate_options);
 
 
  574boost::shared_ptr<PoolParser>
 
  576    return (boost::make_shared<Pool4Parser>());
 
 
  601    } 
catch (
const std::exception& ex) {
 
  603                  "subnet configuration failed: " << ex.what());
 
  613    if (options_params) {
 
  615        opt_parser->parse(
subnet_->getCfgOption(), options_params, encapsulate_options);
 
 
  623    std::string subnet_txt;
 
  625        subnet_txt = 
getString(params, 
"subnet");
 
  629                 "mandatory 'subnet' parameter is missing for a subnet being" 
  630                  " configured (" << params->getPosition() << 
")");
 
  634    boost::erase_all(subnet_txt, 
" ");
 
  635    boost::erase_all(subnet_txt, 
"\t");
 
  642    size_t pos = subnet_txt.find(
"/");
 
  643    if (pos == string::npos) {
 
  646                  "Invalid subnet syntax (prefix/len expected):" << subnet_txt
 
  647                  << 
" (" << elem->getPosition() << 
")");
 
  657        len = boost::lexical_cast<unsigned int>(subnet_txt.substr(pos + 1));
 
  658    } 
catch (
const boost::bad_lexical_cast&) {
 
  661                  subnet_txt.substr(pos+1) << 
"' is not an integer (" 
  662                   << elem->getPosition() << 
")");
 
  666    if ((addr.
isV6() && len > 128) ||
 
  667        (addr.
isV4() && len > 32)) {
 
  670                  "Invalid prefix length specified for subnet: " << len
 
  671                  << 
" (" << elem->getPosition() << 
")");
 
  678    for (
auto const& pool : *
pools_) {
 
  685                      ex.
what() << 
" (" << params->getPosition() << 
")");
 
  694                      << user_context->getPosition() << 
")");
 
  696        subnet_->setContext(user_context);
 
 
  707boost::shared_ptr<OptionDataListParser>
 
  727        parser->parse(
pools_, pools, encapsulate_options);
 
  735                  "Failed to create an IPv4 subnet (" <<
 
  736                  subnet->getPosition() << 
")");
 
  743                  "Invalid Subnet4 cast in Subnet4ConfigParser::parse");
 
  757        for (
auto const& h : hosts) {
 
  764    auto network4 = boost::dynamic_pointer_cast<Network>(sn4ptr);
 
  768    sn4ptr->createAllocators();
 
 
  777    int64_t subnet_id_max = 
static_cast<int64_t
>(SUBNET_ID_MAX);
 
  787    mutable_params = boost::const_pointer_cast<Element>(params);
 
  790    NetworkPtr network = boost::dynamic_pointer_cast<Network>(subnet4);
 
  793    std::ostringstream output;
 
  794    output << addr << 
"/" << 
static_cast<int>(len) << 
" with params: ";
 
  796    bool has_renew = !subnet4->getT1().unspecified();
 
  797    bool has_rebind = !subnet4->getT2().unspecified();
 
  803        renew = subnet4->getT1().get();
 
  804        output << 
"t1=" << renew << 
", ";
 
  807        rebind = subnet4->getT2().get();
 
  808        output << 
"t2=" << rebind << 
", ";
 
  811    if (!subnet4->getValid().unspecified()) {
 
  812        output << 
"valid-lifetime=" << subnet4->getValid().get();
 
  818    if (params->contains(
"match-client-id")) {
 
  819        bool match_client_id = 
getBoolean(params, 
"match-client-id");
 
  820        subnet4->setMatchClientId(match_client_id);
 
  824    if (params->contains(
"authoritative")) {
 
  825        bool authoritative = 
getBoolean(params, 
"authoritative");
 
  826        subnet4->setAuthoritative(authoritative);
 
  832    if (params->contains(
"next-server")) {
 
  835            next_server = 
getString(params, 
"next-server");
 
  836            if (!next_server.empty()) {
 
  837                subnet4->setSiaddr(
IOAddress(next_server));
 
  843                pos = next->getPosition().str();
 
  845                pos = params->getPosition().str();
 
  848                      << next_server << 
"(" << pos << 
")");
 
  853    if (params->contains(
"server-hostname")) {
 
  854        std::string sname = 
getString(params, 
"server-hostname");
 
  855        if (!sname.empty()) {
 
  860                          << sname.length() << 
" (" 
  861                          << 
error->getPosition() << 
")");
 
  863            subnet4->setSname(sname);
 
  868    if (params->contains(
"boot-file-name")) {
 
  869        std::string filename =
getString(params, 
"boot-file-name");
 
  870        if (!filename.empty()) {
 
  875                          << filename.length() << 
" (" 
  876                          << 
error->getPosition() << 
")");
 
  878            subnet4->setFilename(filename);
 
  884    if (params->contains(
"interface")) {
 
  885        std::string iface = 
getString(params, 
"interface");
 
  886        if (!iface.empty()) {
 
  890                          << 
" for subnet " << subnet4->toText()
 
  891                          << 
" is not present in the system (" 
  892                          << 
error->getPosition() << 
")");
 
  895            subnet4->setIface(iface);
 
  900    if (params->contains(
"client-class")) {
 
  901        string client_class = 
getString(params, 
"client-class");
 
  902        if (!client_class.empty()) {
 
  903            subnet4->allowClientClass(client_class);
 
  909                                           boost::dynamic_pointer_cast<Network>(subnet4), ph::_1));
 
  913                                               boost::dynamic_pointer_cast<Network>(subnet4), ph::_1));
 
  916    if (params->contains(
"4o6-interface")) {
 
  917        string iface4o6 = 
getString(params, 
"4o6-interface");
 
  918        if (!iface4o6.empty()) {
 
  919            subnet4->get4o6().setIface4o6(iface4o6);
 
  920            subnet4->get4o6().enabled(
true);
 
  925    if (params->contains(
"4o6-subnet")) {
 
  926        string subnet4o6 = 
getString(params, 
"4o6-subnet");
 
  927        if (!subnet4o6.empty()) {
 
  928            size_t slash = subnet4o6.find(
"/");
 
  929            if (slash == std::string::npos) {
 
  931                          << subnet4o6 << 
", expected format: prefix6/length");
 
  933            string prefix = subnet4o6.substr(0, slash);
 
  934            string lenstr = subnet4o6.substr(slash + 1);
 
  938                len = boost::lexical_cast<unsigned int>(lenstr.c_str());
 
  939            } 
catch (
const boost::bad_lexical_cast &) {
 
  941                          "4o6-subnet parameter: " << subnet4o6 << 
", expected 0..128 value");
 
  943            subnet4->get4o6().setSubnet4o6(
IOAddress(prefix), len);
 
  944            subnet4->get4o6().enabled(
true);
 
  949    if (params->contains(
"4o6-interface-id")) {
 
  950        std::string ifaceid = 
getString(params, 
"4o6-interface-id");
 
  951        if (!ifaceid.empty()) {
 
  954            subnet4->get4o6().setInterfaceId(opt);
 
  955            subnet4->get4o6().enabled(
true);
 
  976    if (params->contains(
"offer-lifetime")) {
 
  977        uint32_t offer_lft = 
getInteger(params, 
"offer-lifetime");
 
  978        subnet4->setOfferLft(offer_lft);
 
  982    Network4Ptr network4 = boost::dynamic_pointer_cast<Network4>(subnet4);
 
 
  989    const IOAddress& address = host->getIPv4Reservation();
 
  990    if (!address.
isV4Zero() && !subnet->inRange(address)) {
 
  992                  << 
"' is not within the IPv4 subnet '" 
  993                  << subnet->
toText() << 
"'");
 
 
  997boost::shared_ptr<PoolsListParser>
 
  999    return (boost::make_shared<Pools4ListParser>());
 
 
 1011                                bool encapsulate_options) {
 
 1013    for (
auto const& subnet_json : subnets_list->listValue()) {
 
 1016        Subnet4Ptr subnet = parser->parse(subnet_json, encapsulate_options);
 
 1023                cfg->getCfgSubnets4()->add(subnet);
 
 1025            } 
catch (
const std::exception& ex) {
 
 1027                          << subnet_json->getPosition() << 
")");
 
 
 1037                                bool encapsulate_options) {
 
 1039    for (
auto const& subnet_json : subnets_list->listValue()) {
 
 1042        Subnet4Ptr subnet = parser->parse(subnet_json, encapsulate_options);
 
 1045                auto ret = subnets.insert(subnet);
 
 1048                              "can't store subnet because of conflict");
 
 1051            } 
catch (
const std::exception& ex) {
 
 1053                          << subnet_json->getPosition() << 
")");
 
 
 1060boost::shared_ptr<Subnet4ConfigParser>
 
 1062    return (boost::make_shared<Subnet4ConfigParser>(
check_iface_));
 
 
 1071                              (ptype), addr, len)));
 
 
 1078                              (ptype), min, max)));
 
 
 1086                        bool encapsulate_options) {
 
 1087    for (
auto const& pool : pools_list->listValue()) {
 
 1089        parser->parse(pools, pool, AF_INET6, encapsulate_options);
 
 
 1093boost::shared_ptr<PoolParser>
 
 1095    return (boost::make_shared<Pool6Parser>());
 
 
 1105                    bool encapsulate_options) {
 
 1108    std::string addr_str = 
getString(pd_pool, 
"prefix");
 
 1110    uint8_t prefix_len = 
getUint8(pd_pool, 
"prefix-len");
 
 1112    uint8_t delegated_len = 
getUint8(pd_pool, 
"delegated-len");
 
 1114    std::string excluded_prefix_str = 
"::";
 
 1115    if (pd_pool->contains(
"excluded-prefix")) {
 
 1116        excluded_prefix_str = 
getString(pd_pool, 
"excluded-prefix");
 
 1119    uint8_t excluded_prefix_len = 0;
 
 1120    if (pd_pool->contains(
"excluded-prefix-len")) {
 
 1121        excluded_prefix_len = 
getUint8(pd_pool, 
"excluded-prefix-len");
 
 1142                              excluded_prefix_len));
 
 1143    } 
catch (
const std::exception& ex) {
 
 1148                  << 
" (" << pd_pool->getPosition() << 
")");
 
 1154        if (pool_id->intValue() <= 0) {
 
 1156                      << 
" a positive integer greater than 0");
 
 1157        } 
else if (pool_id->intValue() > numeric_limits<uint32_t>::max()) {
 
 1159                      << 
" a 32 bit unsigned integer");
 
 1162        pool_->setID(pool_id->intValue());
 
 1174        opts_parser->parse(
pool_->getCfgOption(), option_data, encapsulate_options);
 
 1183        if (!cclass.empty()) {
 
 1184            pool_->allowClientClass(cclass);
 
 1191                                                      boost::dynamic_pointer_cast<Pool>(
pool_), ph::_1));
 
 1196                                                          boost::dynamic_pointer_cast<Pool>(
pool_), ph::_1));
 
 1199    pools->push_back(
pool_);
 
 
 1202boost::shared_ptr<OptionDataListParser>
 
 1204    return (boost::make_shared<OptionDataListParser>(AF_INET6));
 
 
 1212    for (
auto const& pd_pool : pd_pool_list->listValue()) {
 
 1214        parser->parse(pools, pd_pool);
 
 
 1218boost::shared_ptr<PdPoolParser>
 
 1220    return (boost::make_shared<PdPoolParser>());
 
 
 1238        parser->parse(
pools_, pools, encapsulate_options);
 
 1243        parser->parse(
pools_, pd_pools);
 
 1251                  "Failed to create an IPv6 subnet (" <<
 
 1252                  subnet->getPosition() << 
")");
 
 1259                  "Invalid Subnet6 cast in Subnet6ConfigParser::parse");
 
 1273        for (
auto const& h : hosts) {
 
 1280    auto network = boost::dynamic_pointer_cast<Network>(sn6ptr);
 
 1284    auto network6 = boost::dynamic_pointer_cast<Network6>(sn6ptr);
 
 1288    sn6ptr->createAllocators();
 
 
 1298        .arg(code).arg(addr.
toText());
 
 
 1305    int64_t subnet_id_max = 
static_cast<int64_t
>(SUBNET_ID_MAX);
 
 1312    if (params->contains(
"rapid-commit")) {
 
 1313        rapid_commit = 
getBoolean(params, 
"rapid-commit");
 
 1328    mutable_params = boost::const_pointer_cast<Element>(params);
 
 1336        subnet6->setRapidCommit(rapid_commit);
 
 1339    std::ostringstream output;
 
 1340    output << addr << 
"/" << 
static_cast<int>(len) << 
" with params: ";
 
 1343    bool has_renew = !subnet6->getT1().unspecified();
 
 1344    bool has_rebind = !subnet6->getT2().unspecified();
 
 1346    int64_t rebind = -1;
 
 1349        renew = subnet6->getT1().get();
 
 1350        output << 
"t1=" << renew << 
", ";
 
 1353        rebind = subnet6->getT2().get();
 
 1354        output << 
"t2=" << rebind << 
", ";
 
 1357    if (!subnet6->getPreferred().unspecified()) {
 
 1358        output << 
"preferred-lifetime=" << subnet6->getPreferred().get() << 
", ";
 
 1360    if (!subnet6->getValid().unspecified()) {
 
 1361        output << 
"valid-lifetime=" << subnet6->getValid().get();
 
 1363    if (!subnet6->getRapidCommit().unspecified()) {
 
 1364        output << 
", rapid-commit is " 
 1365               << boolalpha << subnet6->getRapidCommit().get();
 
 1373    if (params->contains(
"interface-id")) {
 
 1374        ifaceid = 
getString(params, 
"interface-id");
 
 1378    if (params->contains(
"interface")) {
 
 1388                  "parser error: interface (defined for locally reachable " 
 1389                  "subnets) and interface-id (defined for subnets reachable" 
 1390                  " via relays) cannot be defined at the same time for " 
 1391                  "subnet " << addr << 
"/" << (
int)len << 
"(" 
 1392                  << params->getPosition() << 
")");
 
 1397        std::string ifaceid_value = ifaceid.
get();
 
 1398        OptionBuffer tmp(ifaceid_value.begin(), ifaceid_value.end());
 
 1400        subnet6->setInterfaceId(opt);
 
 1409                      << 
" for subnet " << subnet6->toText()
 
 1410                      << 
" is not present in the system (" 
 1411                      << 
error->getPosition() << 
")");
 
 1414        subnet6->setIface(iface);
 
 1418    if (params->contains(
"client-class")) {
 
 1419        string client_class = 
getString(params, 
"client-class");
 
 1420        if (!client_class.empty()) {
 
 1421            subnet6->allowClientClass(client_class);
 
 1427                                           boost::dynamic_pointer_cast<Network>(subnet6), ph::_1));
 
 1431                                               boost::dynamic_pointer_cast<Network>(subnet6), ph::_1));
 
 
 1449    BOOST_FOREACH(
auto const& it, range) {
 
 1450        const IOAddress& address = it.second.getPrefix();
 
 1451        if (!subnet->inRange(address)) {
 
 1453                      << 
"' is not within the IPv6 subnet '" 
 1454                      << subnet->
toText() << 
"'");
 
 
 1459boost::shared_ptr<PoolsListParser>
 
 1461    return (boost::make_shared<Pools6ListParser>());
 
 
 1464boost::shared_ptr<PdPoolsListParser>
 
 1466    return (boost::make_shared<PdPoolsListParser>());
 
 
 1478                                bool encapsulate_options) {
 
 1480    for (
auto const& subnet_json : subnets_list->listValue()) {
 
 1483        Subnet6Ptr subnet = parser->parse(subnet_json, encapsulate_options);
 
 1489            cfg->getCfgSubnets6()->add(subnet);
 
 1491        } 
catch (
const std::exception& ex) {
 
 1493                      << subnet_json->getPosition() << 
")");
 
 
 1502                                bool encapsulate_options) {
 
 1504    for (
auto const& subnet_json : subnets_list->listValue()) {
 
 1507        Subnet6Ptr subnet = parser->parse(subnet_json, encapsulate_options);
 
 1510                auto ret = subnets.insert(subnet);
 
 1513                              "can't store subnet because of conflict");
 
 1516            } 
catch (
const std::exception& ex) {
 
 1518                          << subnet_json->getPosition() << 
")");
 
 
 1525boost::shared_ptr<Subnet6ConfigParser>
 
 1527    return (boost::make_shared<Subnet6ConfigParser>(
check_iface_));
 
 
 1534                                  const std::string& name) {
 
 1537            (scope, name, 
"NameChangeRequest protocol"));
 
 1542                                const std::string& name) {
 
 1545            (scope, name, 
"NameChangeRequest format"));
 
 1550                              const std::string& name) {
 
 1553            (scope, name, 
"ReplaceClientName mode"));
 
 1561    bool enable_updates = 
getBoolean(client_config, 
"enable-updates");
 
 1565    uint32_t server_port = 
getUint32(client_config, 
"server-port");
 
 1567    std::string sender_ip_str = 
getString(client_config, 
"sender-ip");
 
 1569    uint32_t sender_port = 
getUint32(client_config, 
"sender-port");
 
 1571    uint32_t max_queue_size = 
getUint32(client_config, 
"max-queue-size");
 
 1574        getProtocol(client_config, 
"ncr-protocol");
 
 1577        getFormat(client_config, 
"ncr-format");
 
 1580    if (sender_ip_str.empty()) {
 
 1587        } 
catch (
const std::exception& ex) {
 
 1589                      << 
") specified for parameter 'sender-ip' (" 
 1590                      << 
getPosition(
"sender-ip", client_config) << 
")");
 
 1600                  << 
" is not supported. (" 
 1601                  << 
getPosition(
"ncr-format", client_config) << 
")");
 
 1607                  << 
" is not supported. (" 
 1608                  << 
getPosition(
"ncr-protocol", client_config) << 
")");
 
 1613                  "D2ClientConfig error: address family mismatch: " 
 1614                  << 
"server-ip: " << server_ip.
toText()
 
 1615                  << 
" is: " << (server_ip.
isV4() ? 
"IPv4" : 
"IPv6")
 
 1616                  << 
" while sender-ip: " << sender_ip.
toText()
 
 1617                  << 
" is: " << (sender_ip.
isV4() ? 
"IPv4" : 
"IPv6")
 
 1618                  << 
" (" << 
getPosition(
"sender-ip", client_config) << 
")");
 
 1621    if (server_ip == sender_ip && server_port == sender_port) {
 
 1623                  "D2ClientConfig error: server and sender cannot" 
 1624                  " share the exact same IP address/port: " 
 1625                  << server_ip.
toText() << 
"/" << server_port
 
 1626                  << 
" (" << 
getPosition(
"sender-ip", client_config) << 
")");
 
 1639    } 
catch (
const std::exception& ex) {
 
 1641                  << client_config->getPosition() << 
")");
 
 1647        new_config->setContext(user_context);
 
 1650    return (new_config);
 
 
 1669    ElementPtr mutable_d2 = boost::const_pointer_cast<Element>(d2_config);
 
 
 1675    if (compatibility) {
 
 1677        for (
auto const& kv : compatibility->mapValue()) {
 
 1680                          "compatibility parameter values must be " 
 1681                          << 
"boolean (" << kv.first << 
" at " 
 1682                          << kv.second->getPosition() << 
")");
 
 1684            if (kv.first == 
"lenient-option-parsing") {
 
 1686            } 
else if (family == AF_INET) {
 
 1687                if (kv.first == 
"ignore-dhcp-server-identifier") {
 
 1689                } 
else if (kv.first == 
"ignore-rai-link-selection") {
 
 1691                } 
else if (kv.first == 
"exclude-first-last-24") {
 
 1695                              "unsupported compatibility parameter: " 
 1696                              << kv.first << 
" (" << kv.second->getPosition()
 
 1701                          "unsupported compatibility parameter: " 
 1702                          << kv.first << 
" (" << kv.second->getPosition()
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
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.
A generic exception that is thrown if a parameter given to a method or function is considered invalid...
A generic exception that is thrown if a parameter given to a method would refer to or modify out-of-r...
A generic exception that is thrown when an unexpected error condition occurs.
The IOAddress class represents an IP addresses (version agnostic)
static const IOAddress & IPV4_ZERO_ADDRESS()
Returns an address set to all zeros.
bool isV4Zero() const
Convenience function to check if it is an IPv4 zero address.
std::string toText() const
Convert the address to a string.
bool isV6() const
Convenience function to check for an IPv6 address.
bool isV4() const
Convenience function to check for an IPv4 address.
short getFamily() const
Returns the address family.
static const IOAddress & IPV6_ZERO_ADDRESS()
Returns an IPv6 zero address.
HTTP command config aka HTTP control socket info class.
UNIX command config aka UNIX control socket info class.
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
static void checkKeywords(const SimpleKeywords &keywords, isc::data::ConstElementPtr scope)
Checks acceptable keywords with their expected type.
target_type getAndConvert(isc::data::ConstElementPtr scope, const std::string &name, const std::string &type_name)
Returns a converted value from a scope.
static const data::Element::Position & getPosition(const std::string &name, const data::ConstElementPtr parent)
Utility method that returns position of an element.
uint8_t getUint8(ConstElementPtr scope, const std::string &name)
Get an uint8_t value.
static isc::asiolink::IOAddress getAddress(const ConstElementPtr &scope, const std::string &name)
Returns a IOAddress parameter from a scope.
static std::string getString(isc::data::ConstElementPtr scope, const std::string &name)
Returns a string parameter from a scope.
uint32_t getUint32(isc::data::ConstElementPtr scope, const std::string &name)
Returns a value converted to uint32_t.
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.
static int64_t getInteger(isc::data::ConstElementPtr scope, const std::string &name)
Returns an integer parameter from a scope.
static size_t setDefaults(isc::data::ElementPtr scope, const SimpleDefaults &default_values)
Sets the default values.
Common configuration parser for shared networks and subnets.
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.
void parseDdnsParameters(const data::ConstElementPtr &config, DdnsOwnerTypePtr owner)
Parses parameters pertaining to DDNS behavior.
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)
Wrapper class that holds MAC/hardware address sources.
void add(uint32_t source)
Adds additional MAC/hardware address acquisition.
void clear()
Removes any configured MAC/Hardware address sources.
static uint32_t MACSourceFromText(const std::string &name)
Attempts to convert known hardware address sources to uint32_t.
uint16_t getFamily() const
Returns address family.
static CfgMgr & instance()
returns a single instance of Configuration Manager
SrvConfigPtr getStagingCfg()
Returns a pointer to the staging configuration.
void parse(isc::data::ConstElementPtr cfg, isc::dhcp::SrvConfig &srv_cfg)
Parse compatibility flags.
void parse(SrvConfig &srv_cfg, isc::data::ConstElementPtr value)
"Parses" control-sockets structure
D2ClientConfigPtr parse(isc::data::ConstElementPtr d2_client_cfg)
Parses a given dhcp-ddns element into D2ClientConfig.
static const isc::data::SimpleDefaults D2_CLIENT_CONFIG_DEFAULTS
Defaults for the D2 client configuration.
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.
static ReplaceClientNameMode stringToReplaceClientNameMode(const std::string &mode_str)
Converts labels to ReplaceClientNameMode enum values.
ReplaceClientNameMode
Defines the client name replacement modes.
An exception that is thrown if an error occurs while configuring the D2 DHCP DDNS client.
To be removed. Please use ConfigError instead.
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.
static void setRuntimeOptionDefs(const OptionDefSpaceContainer &defs)
Copies option definitions created at runtime.
void parse(CfgMACSource &mac_sources, isc::data::ConstElementPtr value)
parses parameters value
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.
OptionDefListParser(const uint16_t address_family)
Constructor.
void parse(CfgOptionDefPtr cfg, isc::data::ConstElementPtr def_list)
Parses a list of option definitions, create them and store in cfg.
Parser for a single option definition.
OptionDefinitionPtr parse(isc::data::ConstElementPtr option_def)
Parses an entry that describes single option definition.
OptionDefParser(const uint16_t address_family)
Constructor.
Base class representing a DHCP option definition.
static bool validateName(const std::string &name)
Checks that the provided option space name is valid.
Universe
defines option universe DHCPv4 or DHCPv6
PdPoolParser()
Constructor.
virtual boost::shared_ptr< OptionDataListParser > createOptionDataListParser() const
Returns an instance of the OptionDataListParser to be used in parsing the option-data structure.
isc::data::ConstElementPtr user_context_
User context (optional, may be null)
void parse(PoolStoragePtr pools, data::ConstElementPtr pd_pool_, bool encapsulate_options=true)
Builds a prefix delegation pool from the given configuration.
isc::dhcp::Pool6Ptr pool_
Pointer to the created pool object.
isc::data::ConstElementPtr client_class_
Client class (a client has to belong to to use this pd-pool)
virtual boost::shared_ptr< PdPoolParser > createPdPoolConfigParser() const
Returns an instance of the PdPoolParser to be used in parsing the prefix delegation pools.
void parse(PoolStoragePtr pools, data::ConstElementPtr pd_pool_list)
Parse configuration entries.
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
PoolPtr poolMaker(asiolink::IOAddress &addr, uint32_t len, int32_t ignored)
Creates a Pool4 object given a IPv4 prefix and the prefix length.
Pool information for IPv4 addresses.
PoolPtr poolMaker(asiolink::IOAddress &addr, uint32_t len, int32_t ptype)
Creates a Pool6 object given a IPv6 prefix and the prefix length.
Pool information for IPv6 addresses and prefixes.
virtual PoolPtr poolMaker(isc::asiolink::IOAddress &addr, uint32_t len, int32_t ptype=0)=0
Creates a Pool object given a IPv4 prefix and the prefix length.
virtual void parse(PoolStoragePtr pools, isc::data::ConstElementPtr pool_structure, const uint16_t address_family, bool encapsulate_options=true)
parses the actual structure
virtual boost::shared_ptr< OptionDataListParser > createOptionDataListParser(const uint16_t address_family) const
Returns an instance of the OptionDataListParser to be used in parsing the option-data structure.
void allowClientClass(const isc::dhcp::ClientClass &class_name)
Adds class clas_name to the allowed client classes list.
void addAdditionalClass(const ClientClass &class_name)
Adds class class_name to the additional classes list.
void parse(PoolStoragePtr pools, data::ConstElementPtr pools_list, bool encapsulate_options=true)
parses the actual structure
virtual boost::shared_ptr< PoolParser > createPoolConfigParser() const
Returns an instance of the Pool4Parser to be used in parsing the address pools.
void parse(PoolStoragePtr pools, data::ConstElementPtr pools_list, bool encapsulate_options=true)
parses the actual structure
virtual boost::shared_ptr< PoolParser > createPoolConfigParser() const
Returns an instance of the Pool6Parser to be used in parsing the address pools.
parser for additional relay information
RelayInfoParser(const isc::dhcp::Option::Universe &family)
constructor
void addAddress(const std::string &name, const std::string &address_str, isc::data::ConstElementPtr relay_elem, const isc::dhcp::Network::RelayInfoPtr &relay_info)
Attempts to add an IP address to list of relay addresses.
void parse(const isc::dhcp::Network::RelayInfoPtr &relay_info, isc::data::ConstElementPtr relay_elem)
parses the actual relay parameters
static const isc::data::SimpleKeywords SUBNET4_PARAMETERS
This table defines all subnet parameters for DHCPv4.
static const isc::data::SimpleKeywords OPTION4_DEF_PARAMETERS
This table defines all option definition parameters.
static const isc::data::SimpleKeywords POOL4_PARAMETERS
This table defines all pool parameters.
static const isc::data::SimpleKeywords POOL6_PARAMETERS
This table defines all pool parameters.
static const isc::data::SimpleKeywords SUBNET6_PARAMETERS
This table defines all subnet parameters for DHCPv6.
static const isc::data::SimpleKeywords OPTION6_DEF_PARAMETERS
This table defines all option definition parameters.
static const isc::data::SimpleKeywords PD_POOL6_PARAMETERS
This table defines all prefix delegation pool parameters.
Specifies current DHCP configuration.
void setUnixControlSocketInfo(const isc::data::ConstElementPtr &control_socket)
Sets information about the UNIX control socket.
void setLenientOptionParsing(bool const value)
Set lenient option parsing compatibility flag.
void setIgnoreServerIdentifier(bool const value)
Set ignore DHCP Server Identifier compatibility flag.
void setIgnoreRAILinkSelection(bool const value)
Set ignore RAI Link Selection compatibility flag.
void setExcludeFirstLast24(bool const value)
Set exclude .0 and .255 addresses in subnets bigger than /24 flag.
void setHttpControlSocketInfo(const isc::data::ConstElementPtr &control_socket)
Sets information about the HTTP/HTTPS control socket.
Subnet4ConfigParser(bool check_iface=true)
Constructor.
virtual boost::shared_ptr< PoolsListParser > createPoolsListParser() const
Returns an instance of the Pools4ListParser to be used in parsing the address pools.
void validateResv(const Subnet4Ptr &subnet, ConstHostPtr host)
Verifies the host reservation address is in the subnet range.
void initSubnet(data::ConstElementPtr params, asiolink::IOAddress addr, uint8_t len)
Instantiates the IPv4 Subnet based on a given IPv4 address and prefix length.
Subnet4Ptr parse(data::ConstElementPtr subnet, bool encapsulate_options=true)
Parses a single IPv4 subnet configuration and adds to the Configuration Manager.
static Subnet4Ptr create(const isc::asiolink::IOAddress &prefix, uint8_t length, const util::Triplet< uint32_t > &t1, const util::Triplet< uint32_t > &t2, const util::Triplet< uint32_t > &valid_lifetime, const SubnetID id)
Factory function creating an instance of the Subnet4.
virtual boost::shared_ptr< PoolsListParser > createPoolsListParser() const
Returns an instance of the Pools6ListParser to be used in parsing the address pools.
virtual boost::shared_ptr< PdPoolsListParser > createPdPoolsListParser() const
Returns an instance of the PdPools6ListParser to be used in parsing the prefix delegation pools.
Subnet6Ptr parse(data::ConstElementPtr subnet, bool encapsulate_options=true)
Parses a single IPv6 subnet configuration and adds to the Configuration Manager.
void initSubnet(isc::data::ConstElementPtr params, isc::asiolink::IOAddress addr, uint8_t len)
Instantiates the IPv6 Subnet based on a given IPv6 address and prefix length.
virtual void duplicateOptionWarning(uint32_t code, asiolink::IOAddress &addr)
Issues a DHCP6 server specific warning regarding duplicate subnet options.
void validateResvs(const Subnet6Ptr &subnet, ConstHostPtr host)
Verifies host reservation addresses are in the subnet range.
Subnet6ConfigParser(bool check_iface=true)
Constructor.
static Subnet6Ptr create(const isc::asiolink::IOAddress &prefix, uint8_t length, const util::Triplet< uint32_t > &t1, const util::Triplet< uint32_t > &t2, const util::Triplet< uint32_t > &preferred_lifetime, const util::Triplet< uint32_t > &valid_lifetime, const SubnetID id)
Factory function creating an instance of the Subnet4.
SubnetConfigParser(uint16_t family, bool check_iface=true)
constructor
isc::dhcp::SubnetPtr subnet_
Pointer to the created subnet object.
void createSubnet(isc::data::ConstElementPtr data)
Create a new subnet using a data from child parsers.
virtual void initSubnet(isc::data::ConstElementPtr params, isc::asiolink::IOAddress addr, uint8_t len)=0
Instantiates the subnet based on a given IP prefix and prefix length.
isc::dhcp::Network::RelayInfoPtr relay_info_
Pointer to relay information.
uint16_t address_family_
Address family: AF_INET or AF_INET6.
SubnetPtr parse(isc::data::ConstElementPtr subnet, bool encapsulate_options)
parses a subnet description and returns Subnet{4,6} structure
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.
PoolStoragePtr pools_
Storage for pools belonging to this subnet.
bool check_iface_
Check if the specified interface exists in the system.
size_t parse(SrvConfigPtr cfg, data::ConstElementPtr subnets_list, bool encapsulate_options=true)
parses contents of the list
Subnets4ListConfigParser(bool check_iface=true)
constructor
virtual boost::shared_ptr< Subnet4ConfigParser > createSubnetConfigParser() const
Returns an instance of the Subnet4ConfigParser to be used in parsing the subnets.
virtual boost::shared_ptr< Subnet6ConfigParser > createSubnetConfigParser() const
Returns an instance of the Subnet6ConfigParser to be used in parsing the subnets.
Subnets6ListConfigParser(bool check_iface=true)
constructor
bool check_iface_
Check if the specified interface exists in the system.
size_t parse(SrvConfigPtr cfg, data::ConstElementPtr subnets_list, bool encapsulate_options=true)
parses contents of the list
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.
This template specifies a parameter value.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
#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.
boost::shared_ptr< const Element > ConstElementPtr
std::vector< SimpleDefault > SimpleDefaults
This specifies all default values in a given scope (e.g. a subnet).
boost::shared_ptr< Element > ElementPtr
NameChangeProtocol stringToNcrProtocol(const std::string &protocol_str)
Function which converts text labels to NameChangeProtocol enums.
NameChangeFormat
Defines the list of data wire formats supported.
NameChangeProtocol
Defines the list of socket protocols supported.
std::string ncrProtocolToString(NameChangeProtocol protocol)
Function which converts NameChangeProtocol enums to text labels.
NameChangeFormat stringToNcrFormat(const std::string &fmt_str)
Function which converts labels to NameChangeFormat enum values.
std::string ncrFormatToString(NameChangeFormat format)
Function which converts NameChangeFormat enums to text labels.
isc::log::Logger dhcpsrv_logger("dhcpsrv")
DHCP server library Logger.
boost::shared_ptr< const CfgGlobals > ConstCfgGlobalsPtr
Const shared pointer to a CfgGlobals instance.
boost::shared_ptr< Subnet > SubnetPtr
A generic pointer to either Subnet4 or Subnet6 object.
const isc::log::MessageID DHCPSRV_CFGMGR_NEW_SUBNET6
boost::shared_ptr< Subnet4 > Subnet4Ptr
A pointer to a Subnet4 object.
boost::shared_ptr< Network4 > Network4Ptr
Pointer to the Network4 object.
std::vector< PoolPtr > PoolStorage
a collection of pools
boost::shared_ptr< D2ClientConfig > D2ClientConfigPtr
Defines a pointer for D2ClientConfig instances.
boost::shared_ptr< CfgOption > CfgOptionPtr
Non-const pointer.
boost::shared_ptr< CfgOptionDef > CfgOptionDefPtr
Non-const pointer.
const isc::log::MessageID DHCPSRV_CFGMGR_OPTION_DUPLICATE
boost::shared_ptr< Subnet6 > Subnet6Ptr
A pointer to a Subnet6 object.
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< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
std::pair< IPv6ResrvIterator, IPv6ResrvIterator > IPv6ResrvRange
std::vector< HostPtr > HostCollection
Collection of the Host objects.
boost::shared_ptr< OptionDefinition > OptionDefinitionPtr
Pointer to option definition object.
boost::shared_ptr< PoolStorage > PoolStoragePtr
boost::shared_ptr< Pool > PoolPtr
a pointer to either IPv4 or IPv6 Pool
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.
uint32_t SubnetID
Defines unique IPv4 or IPv6 subnet identifier.
const isc::log::MessageID DHCPSRV_CFGMGR_NEW_SUBNET4
boost::shared_ptr< const Host > ConstHostPtr
Const pointer to the Host object.
boost::shared_ptr< Network > NetworkPtr
Pointer to the Network object.
std::vector< uint8_t > OptionBuffer
buffer types used in DHCP code.
boost::shared_ptr< Option > OptionPtr
vector< string > tokens(const string &text, const string &delim, bool escape)
Split string into tokens.
Defines the logger used by the top-level component of kea-lfc.
#define DHCP4_OPTION_SPACE
global std option spaces
#define DHCP6_OPTION_SPACE
Type
Type of lease or pool.