33#include <boost/scoped_ptr.hpp> 
   34#include <boost/algorithm/string.hpp> 
   93            if (txt == 
"address") {
 
   95            } 
else if (txt == 
"hw-address") {
 
   97            } 
else if (txt == 
"duid") {
 
   99            } 
else if (txt == 
"client-id") {
 
  103                          << txt << 
", the only supported values are: " 
  104                          "address, hw-address, duid");
 
 
 
  390                                    const int control_result,
 
  391                                    const std::string& error_message) 
const;
 
  404                              short family = AF_INET) 
const;
 
  466        if (!user_context || (user_context->getType() != 
Element::map)) {
 
  473        return (
isc->get(
"relay-info"));
 
 
 
  523    if (!lease->stateExpiredReclaimed()) {
 
  526                                   "assigned-addresses"),
 
  527            static_cast<int64_t
>(1));
 
  537                                                                  "assigned-addresses")),
 
  538                    static_cast<int64_t
>(1));
 
  542        if (lease->stateDeclined()) {
 
  547                                       "declined-addresses"),
 
  548                static_cast<int64_t
>(1));
 
  554                                                                  "declined-addresses")),
 
  555                    static_cast<int64_t
>(1));
 
 
  563    if (lease->stateRegistered()) {
 
  566            static_cast<int64_t
>(1));
 
  567    } 
else if (!lease->stateExpiredReclaimed()) {
 
  571                                   "assigned-nas" : 
"assigned-pds"),
 
  572            static_cast<int64_t
>(1));
 
  577            pool = subnet->getPool(lease->type_, lease->addr_, 
false);
 
  582                                                                  "pool" : 
"pd-pool", pool->getID(),
 
  584                                                                  "assigned-nas" : 
"assigned-pds")),
 
  585                    static_cast<int64_t
>(1));
 
  589        if (lease->stateDeclined()) {
 
  594                                       "declined-addresses"),
 
  595                static_cast<int64_t
>(1));
 
  601                                                                  "declined-addresses")),
 
  602                    static_cast<int64_t
>(1));
 
 
  611    if (!existing->stateExpiredReclaimed()) {
 
  616        if (existing->subnet_id_ != lease->subnet_id_) {
 
  619                                       "assigned-addresses"),
 
  620                static_cast<int64_t
>(-1));
 
  629                                                                      "assigned-addresses")),
 
  630                        static_cast<int64_t
>(-1));
 
  635        if (existing->stateDeclined()) {
 
  641                                       "declined-addresses"),
 
  642                static_cast<int64_t
>(-1));
 
  648                                                                  "declined-addresses")),
 
  649                    static_cast<int64_t
>(-1));
 
  655        if (!lease->stateExpiredReclaimed()) {
 
  657            if (existing->subnet_id_ != lease->subnet_id_) {
 
  660                                           "assigned-addresses"),
 
  661                    static_cast<int64_t
>(1));
 
  670                                                                          "assigned-addresses")),
 
  671                            static_cast<int64_t
>(1));
 
  676            if (lease->stateDeclined()) {
 
  682                                           "declined-addresses"),
 
  683                    static_cast<int64_t
>(1));
 
  689                                                                      "declined-addresses")),
 
  690                        static_cast<int64_t
>(1));
 
  696        if (!lease->stateExpiredReclaimed()) {
 
  700                                       "assigned-addresses"),
 
  701                static_cast<int64_t
>(1));
 
  711                                                                      "assigned-addresses")),
 
  712                        static_cast<int64_t
>(1));
 
  716            if (lease->stateDeclined()) {
 
  722                                           "declined-addresses"),
 
  723                    static_cast<int64_t
>(1));
 
  729                                                                      "declined-addresses")),
 
  730                        static_cast<int64_t
>(1));
 
 
  741    if (existing->stateRegistered()) {
 
  742        if (existing->subnet_id_ != lease->subnet_id_) {
 
  746                static_cast<int64_t
>(-1));
 
  750                static_cast<int64_t
>(1));
 
  752    } 
else if (!existing->stateExpiredReclaimed()) {
 
  757        if (existing->subnet_id_ != lease->subnet_id_) {
 
  761                                       "assigned-nas" : 
"assigned-pds"),
 
  762                static_cast<int64_t
>(-1));
 
  766                pool = subnet->getPool(existing->type_, existing->addr_, 
false);
 
  771                                                                      "pool" : 
"pd-pool", pool->getID(),
 
  773                                                                      "assigned-nas" : 
"assigned-pds")),
 
  774                        static_cast<int64_t
>(-1));
 
  779        if (existing->stateDeclined()) {
 
  785                                       "declined-addresses"),
 
  786                static_cast<int64_t
>(-1));
 
  792                                                                  "declined-addresses")),
 
  793                    static_cast<int64_t
>(-1));
 
  799        if (!lease->stateExpiredReclaimed()) {
 
  801            if (existing->subnet_id_ != lease->subnet_id_) {
 
  805                                           "assigned-nas" : 
"assigned-pds"),
 
  806                    static_cast<int64_t
>(1));
 
  810                    pool = subnet->getPool(lease->type_, lease->addr_, 
false);
 
  815                                                                          "pool" : 
"pd-pool", pool->getID(),
 
  817                                                                          "assigned-nas" : 
"assigned-pds")),
 
  818                            static_cast<int64_t
>(1));
 
  823            if (lease->stateDeclined()) {
 
  829                                           "declined-addresses"),
 
  830                    static_cast<int64_t
>(1));
 
  836                                                                      "declined-addresses")),
 
  837                        static_cast<int64_t
>(1));
 
  843        if (!lease->stateExpiredReclaimed()) {
 
  848                                       "assigned-nas" : 
"assigned-pds"),
 
  849                static_cast<int64_t
>(1));
 
  854                pool = subnet->getPool(lease->type_, lease->addr_, 
false);
 
  859                                                                      "pool" : 
"pd-pool", pool->getID(),
 
  861                                                                      "assigned-nas" : 
"assigned-pds")),
 
  862                        static_cast<int64_t
>(1));
 
  866            if (lease->stateDeclined()) {
 
  872                                           "declined-addresses"),
 
  873                    static_cast<int64_t
>(1));
 
  879                                                                      "declined-addresses")),
 
  880                        static_cast<int64_t
>(1));
 
 
  889    if (!lease->stateExpiredReclaimed()) {
 
  892                                   "assigned-addresses"),
 
  893            static_cast<int64_t
>(-1));
 
  903                                                                  "assigned-addresses")),
 
  904                    static_cast<int64_t
>(-1));
 
  908        if (lease->stateDeclined()) {
 
  913                                       "declined-addresses"),
 
  914                static_cast<int64_t
>(-1));
 
  920                                                                  "declined-addresses")),
 
  921                    static_cast<int64_t
>(-1));
 
 
  929    if (lease->stateRegistered()) {
 
  933            static_cast<int64_t
>(-1));
 
  934    } 
else if (!lease->stateExpiredReclaimed()) {
 
  938                                   "assigned-nas" : 
"assigned-pds"),
 
  939            static_cast<int64_t
>(-1));
 
  944            pool = subnet->getPool(lease->type_, lease->addr_, 
false);
 
  949                                                                  "pool" : 
"pd-pool", pool->getID(),
 
  951                                                                  "assigned-nas" : 
"assigned-pds")),
 
  952                    static_cast<int64_t
>(-1));
 
  956        if (lease->stateDeclined()) {
 
  961                                       "declined-addresses"),
 
  962                static_cast<int64_t
>(-1));
 
  968                                                                  "declined-addresses")),
 
  969                    static_cast<int64_t
>(-1));
 
 
  978    if (force_create && !existing) {
 
  982                      "lost race between calls to get and add");
 
  997                  << lease->addr_ << 
" either because the lease has been " 
  998                  "deleted or it has changed in the database, in both cases a " 
  999                  "retry might succeed");
 
 
 1010    if (force_create && !existing) {
 
 1014                      "lost race between calls to get and add");
 
 1021        if (existing->stateRegistered() && !lease->stateRegistered()) {
 
 1024        } 
else if (!existing->stateRegistered() && lease->stateRegistered()) {
 
 1026                      << 
" can't be registered");
 
 1037        if ((!old_extended_info && !extended_info) ||
 
 1038            (old_extended_info && extended_info &&
 
 1039             (*old_extended_info == *extended_info))) {
 
 1049                  << lease->addr_ << 
" either because the lease has been " 
 1050                  "deleted or it has changed in the database, in both cases a " 
 1051                  "retry might succeed");
 
 
 1064    string lease_address = 
"unknown";
 
 1075        bool force_create = 
false;
 
 1082                lease_address = lease4->addr_.toText();
 
 1090                    if (resource_handler.
tryLock4(lease4->addr_)) {
 
 1094                                  "ResourceBusy: IP address:" << lease4->addr_
 
 1095                                  << 
" could not be added.");
 
 1104                resp << 
"Lease for address " << lease4->addr_.toText()
 
 1105                     << 
", subnet-id " << lease4->subnet_id_ << 
" added.";
 
 1111                lease_address = lease6->addr_.toText();
 
 1119                    if (resource_handler.
tryLock(lease6->type_, lease6->addr_)) {
 
 1123                                  "ResourceBusy: IP address:" << lease6->addr_
 
 1124                                  << 
" could not be added.");
 
 1134                    resp << 
"Lease for address " << lease6->addr_.toText()
 
 1135                         << 
", subnet-id " << lease6->subnet_id_ << 
" added.";
 
 1137                    resp << 
"Lease for prefix " << lease6->addr_.toText()
 
 1138                         << 
"/" << 
static_cast<int>(lease6->prefixlen_)
 
 1139                         << 
", subnet-id " << lease6->subnet_id_ << 
" added.";
 
 1150    } 
catch (
const std::exception& ex) {
 
 1160        .arg(lease_address);
 
 
 1173    if (params->contains(
"update-ddns")) {
 
 1186    if (params->contains(
"type")) {
 
 1187        string t = params->get(
"type")->stringValue();
 
 1188        if (t == 
"IA_NA" || t == 
"0") {
 
 1190        } 
else if (t == 
"IA_TA" || t == 
"1") {
 
 1192        } 
else if (t == 
"IA_PD" || t == 
"2") {
 
 1194        } 
else if (t == 
"V4" || t == 
"3") {
 
 1198                      << t << 
", only supported values are: IA_NA, IA_TA," 
 1199                      << 
" IA_PD and V4");
 
 1213            txt << 
"Invalid " << (v6 ? 
"IPv6" : 
"IPv4")
 
 1214                << 
" address specified: " << tmp->stringValue();
 
 1222    tmp = params->get(
"subnet-id");
 
 1231    if (params->contains(
"iaid")) {
 
 1232        x.
iaid = params->get(
"iaid")->intValue();
 
 1243                  " and 'identifier-type' is either missing or not a string.");
 
 1247                  " and 'identifier' is either missing or not a string.");
 
 1276                  " is not supported.");
 
 
 1307                                                "requires hwaddr to be specified");
 
 1320                                                "requires duid to be specified");
 
 1334                                                "requires client-id to be specified");
 
 1348    } 
catch (
const std::exception& ex) {
 
 1358        lease_json = lease4->toElement();
 
 1360                                                "IPv4 lease found.", lease_json);
 
 1362    } 
else if (!v4 && lease6) {
 
 1363        lease_json = lease6->toElement();
 
 1365                                                "IPv6 lease found.", lease_json);
 
 
 1395            const std::vector<ElementPtr>& subnet_ids = subnets->listValue();
 
 1396            for (
auto const& subnet_id : subnet_ids) {
 
 1404                    for (
auto const& lease : leases) {
 
 1406                        leases_json->add(lease_json);
 
 1411                    for (
auto const& lease : leases) {
 
 1413                        leases_json->add(lease_json);
 
 1422                for (
auto const& lease : leases) {
 
 1424                    leases_json->add(lease_json);
 
 1428                for (
auto const& lease : leases) {
 
 1430                    leases_json->add(lease_json);
 
 1435        std::ostringstream s;
 
 1436        s << leases_json->size()
 
 1437          << 
" IPv" << (v4 ? 
"4" : 
"6")
 
 1438          << 
" lease(s) found.";
 
 1440        args->set(
"leases", leases_json);
 
 1448    } 
catch (
const std::exception& ex) {
 
 
 1482        boost::scoped_ptr<IOAddress> from_address;
 
 1484            if (from->stringValue() == 
"start") {
 
 1485                from_address.reset(
new IOAddress(v4 ? 
"0.0.0.0" : 
"::"));
 
 1489                from_address.reset(
new IOAddress(from->stringValue()));
 
 1494                      "a valid IPv" << (v4 ? 
"4" : 
"6") << 
" address");
 
 1499        if (v4 && (!from_address->isV4())) {
 
 1501                      << 
" is not an IPv4 address");
 
 1503        } 
else if (!v4 && from_address->isV4()) {
 
 1505                      << 
" is not an IPv6 address");
 
 1520        size_t page_limit_value = 
static_cast<size_t>(page_limit->intValue());
 
 1531            for (
auto const& lease : leases) {
 
 1533                leases_json->add(lease_json);
 
 1542            for (
auto const& lease : leases) {
 
 1544                leases_json->add(lease_json);
 
 1549        std::ostringstream s;
 
 1550        s << leases_json->size()
 
 1551          << 
" IPv" << (v4 ? 
"4" : 
"6")
 
 1552          << 
" lease(s) found.";
 
 1556        args->set(
"leases", leases_json);
 
 1557        args->set(
"count", 
Element::create(
static_cast<int64_t
>(leases_json->size())));
 
 1567    } 
catch (
const std::exception& ex) {
 
 
 1601        for (
auto const& lease : leases) {
 
 1603            leases_json->add(lease_json);
 
 1606        std::ostringstream s;
 
 1607        s << leases_json->size() << 
" IPv4 lease(s) found.";
 
 1609        args->set(
"leases", leases_json);
 
 1617    } 
catch (
const std::exception& ex) {
 
 
 1651        for (
auto const& lease : leases) {
 
 1653            leases_json->add(lease_json);
 
 1656        std::ostringstream s;
 
 1657        s << leases_json->size() << 
" IPv4 lease(s) found.";
 
 1659        args->set(
"leases", leases_json);
 
 1667    } 
catch (
const std::exception& ex) {
 
 
 1701        for (
auto const& lease : leases) {
 
 1703            leases_json->add(lease_json);
 
 1706        std::ostringstream s;
 
 1707        s << leases_json->size() << 
" IPv6 lease(s) found.";
 
 1709        args->set(
"leases", leases_json);
 
 1717    } 
catch (
const std::exception& ex) {
 
 
 1730        v4 = (
cmd_name_ == 
"lease4-get-by-hostname");
 
 1748        std::string hostname_ = hostname->stringValue();
 
 1750        if (hostname_.empty()) {
 
 1753        boost::algorithm::to_lower(hostname_);
 
 1760            for (
auto const& lease : leases) {
 
 1762                leases_json->add(lease_json);
 
 1768            for (
auto const& lease : leases) {
 
 1770                leases_json->add(lease_json);
 
 1774        std::ostringstream s;
 
 1775        s << leases_json->size()
 
 1776          << 
" IPv" << (v4 ? 
"4" : 
"6")
 
 1777          << 
" lease(s) found.";
 
 1779        args->set(
"leases", leases_json);
 
 1787    } 
catch (
const std::exception& ex) {
 
 
 1815                                            "requires hwaddr to be specified");
 
 1829                                            "requires client-id to be specified");
 
 1862    } 
catch (
const std::exception& ex) {
 
 1870        .arg(lease4->addr_.toText());
 
 
 1885        auto deleted_leases = 
cmd_args_->get(
"deleted-leases");
 
 1888        if (!deleted_leases && !leases) {
 
 1894        if (deleted_leases && (deleted_leases->getType() != 
Element::list)) {
 
 1906        std::list<std::pair<Parameters, Lease6Ptr> > parsed_deleted_list;
 
 1907        if (deleted_leases) {
 
 1908            auto leases_list = deleted_leases->listValue();
 
 1911            for (
auto const& lease_params : leases_list) {
 
 1916                parsed_deleted_list.push_back(std::make_pair(p, lease));
 
 1922        std::list<Lease6Ptr> parsed_leases_list;
 
 1927            auto leases_list = leases->listValue();
 
 1928            for (
auto const& lease_params : leases_list) {
 
 1936                parsed_leases_list.push_back(lease6);
 
 1941        size_t success_count = 0;
 
 1944        if (!parsed_deleted_list.empty()) {
 
 1947            for (
auto const& lease_params_pair : parsed_deleted_list) {
 
 1952                auto lease = lease_params_pair.second;
 
 1965                            if (!failed_deleted_list) {
 
 1976                                                                          "lease not found"));
 
 1980                } 
catch (
const std::exception& ex) {
 
 1982                    if (!failed_deleted_list) {
 
 1995        if (!parsed_leases_list.empty()) {
 
 1999            for (
auto const& lease : parsed_leases_list) {
 
 2002                std::ostringstream text;
 
 2010                        if (resource_handler.
tryLock(lease->type_, lease->addr_)) {
 
 2014                                      "ResourceBusy: IP address:" << lease->addr_
 
 2015                                      << 
" could not be updated.");
 
 2024                } 
catch (
const std::exception& ex) {
 
 2031                    if (!failed_leases_list) {
 
 2046        if (failed_deleted_list || failed_leases_list) {
 
 2051            if (failed_deleted_list) {
 
 2052                args->set(
"failed-deleted-leases", failed_deleted_list);
 
 2056            if (failed_leases_list) {
 
 2057                args->set(
"failed-leases", failed_leases_list);
 
 2062        std::ostringstream resp_text;
 
 2063        resp_text << 
"Bulk apply of " << success_count << 
" IPv6 leases completed.";
 
 2070            .arg(success_count);
 
 2072    } 
catch (
const std::exception& ex) {
 
 
 2112                                            "requires duid to be specified");
 
 2142    } 
catch (
const std::exception& ex) {
 
 2151        .arg(lease6->addr_.toText());
 
 
 2169        bool force_create = 
false;
 
 2181            if (resource_handler.
tryLock4(lease4->addr_)) {
 
 2185                          "ResourceBusy: IP address:" << lease4->addr_
 
 2186                          << 
" could not be updated.");
 
 2197            .arg(lease4->addr_.toText());
 
 2206    } 
catch (
const std::exception& ex) {
 
 
 2231        bool force_create = 
false;
 
 2243            if (resource_handler.
tryLock(lease6->type_, lease6->addr_)) {
 
 2247                          "ResourceBusy: IP address:" << lease6->addr_
 
 2248                          << 
" could not be updated.");
 
 2259            .arg(lease6->addr_.toText());
 
 2268    } 
catch (
const std::exception& ex) {
 
 
 2303            int64_t previous_declined = 0;
 
 2306                previous_declined = observation->getInteger().first;
 
 2311                static_cast<int64_t
>(0));
 
 2315                static_cast<int64_t
>(0));
 
 2322                                                                                             "assigned-addresses")));
 
 2329                                                                                             "declined-addresses")));
 
 2344            for (
auto const& sub : *subs) {
 
 2346                ids << 
" " << sub->getID();
 
 2349                    static_cast<int64_t
>(0));
 
 2353                    static_cast<int64_t
>(0));
 
 2358                                                                                             "assigned-addresses")));
 
 2365                                                                                             "declined-addresses")));
 
 2376        tmp << 
"Deleted " << num << 
" IPv4 lease(s) from subnet(s)" << ids.str();
 
 2380    } 
catch (
const std::exception& ex) {
 
 
 2422            int64_t previous_declined = 0;
 
 2425                previous_declined = observation->getInteger().first;
 
 2430                static_cast<int64_t
>(0));
 
 2434                static_cast<int64_t
>(0));
 
 2438                static_cast<int64_t
>(0));
 
 2442                static_cast<int64_t
>(0));
 
 2456                                                                                             "declined-addresses")));
 
 2480            for (
auto const& sub : *subs) {
 
 2482                ids << 
" " << sub->getID();
 
 2485                    static_cast<int64_t
>(0));
 
 2489                    static_cast<int64_t
>(0));
 
 2493                    static_cast<int64_t
>(0));
 
 2497                    static_cast<int64_t
>(0));
 
 2509                                                                                             "declined-addresses")));
 
 2529        tmp << 
"Deleted " << num << 
" IPv6 lease(s) from subnet(s)" << ids.str();
 
 2533    } 
catch (
const std::exception& ex) {
 
 
 2558            lease6.reset(
new Lease6());
 
 2559            lease6->addr_ = parameters.
addr;
 
 2568        if (!parameters.
duid) {
 
 2570                      "requires duid to be specified");
 
 
 2590                               short family)
 const {
 
 2603    } 
catch (
const std::exception& ex) {
 
 2605                                << 
"' is not a valid IP address.");
 
 2610                  << (family == AF_INET6 ? 
"IPv6" : 
"IPv4")
 
 2611                  << 
" address specified: " << param->stringValue());
 
 
 2619    std::stringstream ss;
 
 2629            ss << 
"DDNS updating is not enabled";
 
 2635                ss << 
"No lease found for: " << addr.
toText();
 
 2637            } 
else if (lease->hostname_.empty()) {
 
 2638                ss << 
"Lease for: " << addr.
toText()
 
 2639                   << 
", has no hostname, nothing to update";
 
 2641            } 
else if (!lease->fqdn_fwd_ && !lease->fqdn_rev_) {
 
 2642                ss << 
"Neither forward nor reverse updates enabled for lease for: " 
 2649                ss << 
"NCR generated for: " << addr.
toText()
 
 2650                   << 
", hostname: " << lease->hostname_;
 
 2656    } 
catch (
const std::exception& ex) {
 
 
 2667    std::stringstream ss;
 
 2677            ss << 
"DDNS updating is not enabled";
 
 2683                ss << 
"No lease found for: " << addr.
toText();
 
 2685            } 
else if (lease->hostname_.empty()) {
 
 2686                ss << 
"Lease for: " << addr.
toText()
 
 2687                   << 
", has no hostname, nothing to update";
 
 2689            } 
else if (!lease->fqdn_fwd_ && !lease->fqdn_rev_) {
 
 2690                ss << 
"Neither forward nor reverse updates enabled for lease for: " 
 2697                ss << 
"NCR generated for: " << addr.
toText()
 
 2698                   << 
", hostname: " << lease->hostname_;
 
 2704    } 
catch (
const std::exception& ex) {
 
 
 2717                                    const int control_result,
 
 2718                                    const std::string& error_message)
 const {
 
 2731    failed_lease_map->set(
"error-message", 
Element::create(error_message));
 
 2733    return (failed_lease_map);
 
 
 2755        std::string filename;
 
 2758        } 
catch (
const std::exception& ex) {
 
 2769        s << (v4 ? 
"IPv4" : 
"IPv6")
 
 2770          << 
" lease database into '" 
 2771          << filename << 
"'.";
 
 2774    } 
catch (
const std::exception& ex) {
 
 
 2785    uint32_t offer_lifetime;
 
 2786    callout_handle.
getArgument(
"offer_lifetime", offer_lifetime);
 
 2787    if (!offer_lifetime) {
 
 2798    callout_handle.
getArgument(
"response4", response);
 
 2801    if (!leases || leases->empty() || !((*leases)[0])) {
 
 2807        if (mgr->evaluateVariables(query, response, lease)) {
 
 2812                  " the lease with address " << lease->addr_ <<
 
 2813                  " either because the lease has been" 
 2814                  " deleted or it has changed in the database");
 
 2815    } 
catch (
const std::exception& ex) {
 
 2817                  << query->getLabel() << 
", :" << ex.what());
 
 
 2830    callout_handle.
getArgument(
"response4", response);
 
 2839    if (leases->empty() || !response || (response->getType() != 
DHCPACK)) {
 
 2849        if (mgr->evaluateVariables(query, response, lease)) {
 
 2854                  " the lease with address " << lease->addr_ <<
 
 2855                  " either because the lease has been" 
 2856                  " deleted or it has changed in the database");
 
 2857    } 
catch (
const std::exception& ex) {
 
 2859                  << query->getLabel() << 
", :" << ex.what());
 
 
 2872    callout_handle.
getArgument(
"response6", response);
 
 2880    if (leases->empty() || !response) {
 
 2886    for (
auto lease : *leases) {
 
 2898            if (lease->valid_lft_) {
 
 2900                if (mgr->evaluateVariables(query, response, lease)) {
 
 2907                .arg(lease->addr_.toText())
 
 2908                .arg(query->getLabel());
 
 2909        } 
catch (
const std::exception& ex) {
 
 2912                .arg(query->getLabel())
 
 2913                .arg(lease->addr_.toText())
 
 2920                              << 
" leases failed to update for " 
 2921                              << query->getLabel());
 
 
 2927    return (impl_->leaseAddHandler(handle));
 
 
 2932    return (impl_->lease6BulkApplyHandler(handle));
 
 
 2937    return (impl_->leaseGetHandler(handle));
 
 
 2942    return (impl_->leaseGetAllHandler(handle));
 
 
 2947    return (impl_->leaseGetPageHandler(handle));
 
 
 2952    return (impl_->leaseGetByHwAddressHandler(handle));
 
 
 2957    return (impl_->leaseGetByClientIdHandler(handle));
 
 
 2962    return (impl_->leaseGetByDuidHandler(handle));
 
 
 2967    return (impl_->leaseGetByHostnameHandler(handle));
 
 
 2972    return (impl_->lease4DelHandler(handle));
 
 
 2977    return (impl_->lease6DelHandler(handle));
 
 
 2982    return (impl_->lease4UpdateHandler(handle));
 
 
 2987    return (impl_->lease6UpdateHandler(handle));
 
 
 2993    return (impl_->lease4WipeHandler(handle));
 
 
 2999    return (impl_->lease6WipeHandler(handle));
 
 
 3004    return (impl_->lease4ResendDdnsHandler(handle));
 
 
 3009    return (impl_->lease6ResendDdnsHandler(handle));
 
 
 3014    return (impl_->leaseWriteHandler(handle));
 
 
 3024    impl_->lease4Offer(callout_handle, mgr);
 
 
 3030    impl_->leases4Committed(callout_handle, mgr);
 
 
 3036    impl_->leases6Committed(callout_handle, mgr);
 
 
static DUID fromText(const std::string &text)
Create DUID from the textual format.
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
Exception thrown when a command failed due to a conflict.
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.
A generic exception that is thrown if a parameter given to a method or function is considered invalid...
A generic exception that is thrown when an unexpected error condition occurs.
The IOAddress class represents an IP addresses (version agnostic)
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.
bool isV6Zero() const
Convenience function to check if it is an IPv4 zero address.
short getFamily() const
Returns the address family.
static const IOAddress & IPV6_ZERO_ADDRESS()
Returns an IPv6 zero address.
Base class that command handler implementers may use for common tasks.
std::string cmd_name_
Stores the command name extracted by a call to extractCommand.
void setErrorResponse(hooks::CalloutHandle &handle, const std::string &text, int status=CONTROL_RESULT_ERROR)
Set the callout argument "response" to indicate an error.
data::ConstElementPtr cmd_args_
Stores the command arguments extracted by a call to extractCommand.
void extractCommand(hooks::CalloutHandle &handle)
Extracts the command name and arguments from a Callout handle.
void setSuccessResponse(hooks::CalloutHandle &handle, const std::string &text)
Set the callout argument "response" to indicate success.
void setResponse(hooks::CalloutHandle &handle, data::ConstElementPtr &response)
Set the callout argument "response" to the given response.
uint32_t getUint32(isc::data::ConstElementPtr scope, const std::string &name)
Returns a value converted to uint32_t.
std::string validatePath(const std::string data_path) const
Validates a file path against the supported directory for DHDP data.
static CfgMgr & instance()
returns a single instance of Configuration Manager
SrvConfigPtr getCurrentCfg()
Returns a pointer to the current configuration.
static ClientIdPtr fromText(const std::string &text)
Create client identifier from the textual format.
Holds DUID (DHCPv6 Unique Identifier)
static TrackingLeaseMgr & instance()
Return current lease manager.
virtual Lease6Collection getLeases6(Lease::Type type, const DUID &duid, uint32_t iaid) const =0
Returns existing IPv6 leases for a given DUID+IA combination.
virtual size_t wipeLeases6(const SubnetID &subnet_id)=0
Virtual method which removes specified leases.
virtual Lease4Collection getLeases4(SubnetID subnet_id) const =0
Returns all IPv4 leases for the particular subnet identifier.
virtual void writeLeases6(const std::string &filename)=0
Write V6 leases to a file.
virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress &addr) const =0
Returns an IPv4 lease for specified IPv4 address.
virtual bool addLease(const Lease4Ptr &lease)=0
Adds an IPv4 lease.
virtual size_t wipeLeases4(const SubnetID &subnet_id)=0
Virtual method which removes specified leases.
virtual void updateLease4(const Lease4Ptr &lease4)=0
Updates IPv4 lease.
virtual void writeLeases4(const std::string &filename)=0
Write V4 leases to a file.
virtual Lease6Ptr getLease6(Lease::Type type, const isc::asiolink::IOAddress &addr) const =0
Returns existing IPv6 lease for a given IPv6 address.
virtual void updateLease6(const Lease6Ptr &lease6)=0
Updates IPv6 lease.
Wraps value holding size of the page with leases.
Attempt to update lease that was not there.
Resource race avoidance RAII handler for DHCPv4.
bool tryLock4(const asiolink::IOAddress &addr)
Tries to acquires a resource.
Resource race avoidance RAII handler.
bool tryLock(Lease::Type type, const asiolink::IOAddress &addr)
Tries to acquires a resource.
Per-packet callout handle.
void getArgument(const std::string &name, T &value) const
Get argument.
Parser for Lease4 structure.
virtual isc::dhcp::Lease4Ptr parse(isc::dhcp::ConstSrvConfigPtr &cfg, const isc::data::ConstElementPtr &lease_info, bool &force_create)
Parses Element tree and tries to convert to Lease4.
Parser for Lease6 structure.
virtual isc::dhcp::Lease6Ptr parse(isc::dhcp::ConstSrvConfigPtr &cfg, const isc::data::ConstElementPtr &lease_info, bool &force_create)
Parses Element tree and tries to convert to Lease4.
Parameters specified for lease commands.
uint32_t iaid
IAID identifier used for v6 leases.
HWAddrPtr hwaddr
Specifies hardware address (used when query_type is TYPE_HWADDR)
Lease::Type lease_type
Lease type (NA,TA or PD) used for v6 leases.
Type query_type
specifies parameter types
Type
specifies type of query (by IP addr, by hwaddr, by DUID)
@ TYPE_DUID
query by DUID (v6 only)
@ TYPE_CLIENT_ID
query by client identifier (v4 only).
@ TYPE_HWADDR
query by hardware address (v4 only)
@ TYPE_ADDR
query by IP address (either v4 or v6)
isc::dhcp::ClientIdPtr client_id
Specifies identifier value (used when query_type is TYPE_CLIENT_ID)
static Type txtToType(const std::string &txt)
Attempts to covert text to one of specified types.
Parameters()
Default constructor.
bool updateDDNS
Indicates whether or not DNS should be updated.
IOAddress addr
Specifies IPv4/v6 address (used when query_type is TYPE_ADDR)
SubnetID subnet_id
Specifies subnet-id (always used)
isc::dhcp::DuidPtr duid
Specifies identifier value (used when query_type is TYPE_DUID)
Wrapper class around reservation command handlers.
int lease4DelHandler(CalloutHandle &handle)
lease4-del command handler
IOAddress getAddressParam(ConstElementPtr params, const std::string name, short family=AF_INET) const
static void lease4Offer(CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
lease4_offer hookpoint handler.
static void updateStatsOnUpdate(const Lease4Ptr &existing, const Lease4Ptr &lease)
Update stats when updating lease.
ElementPtr createFailedLeaseMap(const Lease::Type &lease_type, const IOAddress &lease_address, const DuidPtr &duid, const int control_result, const std::string &error_message) const
Returns a map holding brief information about a lease which failed to be deleted, updated or added.
static bool addOrUpdate6(Lease6Ptr lease, bool force_create)
Add or update lease.
int lease6BulkApplyHandler(CalloutHandle &handle)
lease6-bulk-apply command handler
int leaseGetByDuidHandler(hooks::CalloutHandle &handle)
lease6-get-by-duid command handler
int lease6UpdateHandler(CalloutHandle &handle)
lease6-update handler
int leaseGetPageHandler(hooks::CalloutHandle &handle)
lease4-get-page, lease6-get-page commands handler
Lease6Ptr getIPv6LeaseForDelete(const Parameters ¶meters) const
Convenience function fetching IPv6 address to be used to delete a lease.
int leaseGetByHostnameHandler(hooks::CalloutHandle &handle)
lease4-get-by-hostname and lease6-get-by-hostname commands handler
int lease6DelHandler(CalloutHandle &handle)
lease6-del command handler
int leaseGetByHwAddressHandler(hooks::CalloutHandle &handle)
lease4-get-by-hw-address command handler
static ConstElementPtr getExtendedInfo6(const Lease6Ptr &lease)
Get DHCPv6 extended info.
int leaseGetHandler(CalloutHandle &handle)
lease4-get, lease6-get command handler
static bool addOrUpdate4(Lease4Ptr lease, bool force_create)
Add or update lease.
static void leases4Committed(CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
leases4_committed hookpoint handler.
int lease6WipeHandler(CalloutHandle &handle)
lease6-wipe handler
int leaseGetByClientIdHandler(hooks::CalloutHandle &handle)
lease4-get-by-client-id command handler
int lease6ResendDdnsHandler(CalloutHandle &handle)
lease6-resend-ddns handler
int leaseAddHandler(CalloutHandle &handle)
lease4-add, lease6-add command handler
int lease4ResendDdnsHandler(CalloutHandle &handle)
lease4-resend-ddns handler
static void updateStatsOnAdd(const Lease4Ptr &lease)
Update stats when adding lease.
Parameters getParameters(bool v6, const ConstElementPtr &args)
Extracts parameters required for reservation-get and reservation-del.
static void leases6Committed(CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
leases6_committed hookpoint handler.
int lease4UpdateHandler(CalloutHandle &handle)
lease4-update handler
int lease4WipeHandler(CalloutHandle &handle)
lease4-wipe handler
int leaseGetAllHandler(CalloutHandle &handle)
lease4-get-all, lease6-get-all commands handler
int leaseWriteHandler(CalloutHandle &handle)
lease4-write handler, lease6-write handler
static void updateStatsOnDelete(const Lease4Ptr &lease)
Update stats when deleting lease.
int lease4ResendDdnsHandler(hooks::CalloutHandle &handle)
lease4-resend-ddns command handler
int lease6WipeHandler(hooks::CalloutHandle &handle)
lease6-wipe handler
int leaseGetPageHandler(hooks::CalloutHandle &handle)
lease4-get-page, lease6-get-page commands handler
int lease6DelHandler(hooks::CalloutHandle &handle)
lease6-del command handler
int leaseGetAllHandler(hooks::CalloutHandle &handle)
lease4-get-all, lease6-get-all commands handler
int leaseGetByHostnameHandler(hooks::CalloutHandle &handle)
lease4-get-by-hostname and lease6-get-by-hostname commands handler
void leases4Committed(hooks::CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
leases4_committed hookpoint handler.
int lease4DelHandler(hooks::CalloutHandle &handle)
lease4-del command handler
int leaseWriteHandler(hooks::CalloutHandle &handle)
lease4-write handler, lease6-write handler
int leaseAddHandler(hooks::CalloutHandle &handle)
lease4-add, lease6-add command handler
int leaseGetByClientIdHandler(hooks::CalloutHandle &handle)
lease4-get-by-client-id command handler
void lease4Offer(hooks::CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
lease4_offer hookpoint handler.
int lease4UpdateHandler(hooks::CalloutHandle &handle)
lease4-update handler
int leaseGetHandler(hooks::CalloutHandle &handle)
lease4-get, lease6-get command handler
int leaseGetByHwAddressHandler(hooks::CalloutHandle &handle)
lease4-get-by-hw-address command handler
int lease6UpdateHandler(hooks::CalloutHandle &handle)
lease6-update handler
void leases6Committed(hooks::CalloutHandle &callout_handle, BindingVariableMgrPtr mgr)
leases6_committed hookpoint handler.
int leaseGetByDuidHandler(hooks::CalloutHandle &handle)
lease6-get-by-duid command handler
int lease6BulkApplyHandler(hooks::CalloutHandle &handle)
lease6-bulk-apply command handler
int lease4WipeHandler(hooks::CalloutHandle &handle)
lease4-wipe handler
int lease6ResendDdnsHandler(hooks::CalloutHandle &handle)
lease6-resend-ddns command handler
ObservationPtr getObservation(const std::string &name) const
Returns an observation.
static StatsMgr & instance()
Statistics Manager accessor method.
static std::string generateName(const std::string &context, Type index, const std::string &stat_name)
Generates statistic name in a given context.
RAII class creating a critical section.
static MultiThreadingMgr & instance()
Returns a single instance of Multi Threading Manager.
This file contains several functions and constants that are used for handling commands and responses ...
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
void setValue(const std::string &name, const int64_t value)
Records absolute integer observation.
void addValue(const std::string &name, const int64_t value)
Records incremental integer observation.
const isc::log::MessageID LEASE_CMDS_DEL4
const isc::log::MessageID LEASE_CMDS_WIPE4_FAILED
const isc::log::MessageID LEASE_CMDS_UPDATE6_FAILED
const isc::log::MessageID LEASE_CMDS_UPDATE4_FAILED
const isc::log::MessageID LEASE_CMDS_WIPE6_FAILED
const isc::log::MessageID LEASE_CMDS_UPDATE6_CONFLICT
const isc::log::MessageID LEASE_CMDS_UPDATE4_CONFLICT
const isc::log::MessageID LEASE_CMDS_RESEND_DDNS4_FAILED
const isc::log::MessageID LEASE_CMDS_DEL6
const isc::log::MessageID LEASE_CMDS_ADD4_FAILED
const isc::log::MessageID LEASE_CMDS_LEASES6_COMMITTED_LEASE_ERROR
const isc::log::MessageID LEASE_CMDS_ADD6
const isc::log::MessageID LEASE_CMDS_ADD4
const isc::log::MessageID LEASE_CMDS_WIPE6
const isc::log::MessageID LEASE_CMDS_ADD6_CONFLICT
const isc::log::MessageID LEASE_CMDS_BULK_APPLY6_FAILED
const isc::log::MessageID LEASE_CMDS_UPDATE6
const isc::log::MessageID LEASE_CMDS_RESEND_DDNS4
const isc::log::MessageID LEASE_CMDS_GET6_FAILED
const isc::log::MessageID LEASE_CMDS_WIPE4
const isc::log::MessageID LEASE_CMDS_BULK_APPLY6
const isc::log::MessageID LEASE_CMDS_RESEND_DDNS6_FAILED
const isc::log::MessageID LEASE_CMDS_RESEND_DDNS6
const isc::log::MessageID LEASE_CMDS_GET4_FAILED
const isc::log::MessageID LEASE_CMDS_ADD4_CONFLICT
const isc::log::MessageID LEASE_CMDS_LEASES6_COMMITTED_CONFLICT
const isc::log::MessageID LEASE_CMDS_DEL4_FAILED
const isc::log::MessageID LEASE_CMDS_ADD6_FAILED
const isc::log::MessageID LEASE_CMDS_UPDATE4
const isc::log::MessageID LEASE_CMDS_DEL6_FAILED
An abstract API for lease database.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
#define LOG_INFO(LOGGER, MESSAGE)
Macro to conveniently test info output and log it.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
#define LOG_DEBUG(LOGGER, LEVEL, MESSAGE)
Macro to conveniently test debug output and log it.
const int CONTROL_RESULT_EMPTY
Status code indicating that the specified command was completed correctly, but failed to produce any ...
const int CONTROL_RESULT_ERROR
Status code indicating a general failure.
ConstElementPtr createAnswer()
Creates a standard config/command level success answer message (i.e.
const int CONTROL_RESULT_CONFLICT
Status code indicating that the command was unsuccessful due to a conflict between the command argume...
const int CONTROL_RESULT_SUCCESS
Status code indicating a successful operation.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< Element > ElementPtr
boost::shared_ptr< Lease4Collection > Lease4CollectionPtr
A shared pointer to the collection of IPv4 leases.
boost::shared_ptr< const SrvConfig > ConstSrvConfigPtr
Const pointer to the SrvConfig.
void queueNCR(const NameChangeType &chg_type, const Lease4Ptr &lease)
Creates name change request from the DHCPv4 lease.
boost::shared_ptr< const Subnet6 > ConstSubnet6Ptr
A const pointer to a Subnet6 object.
boost::shared_ptr< const Subnet4 > ConstSubnet4Ptr
A const pointer to a Subnet4 object.
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
boost::shared_ptr< DUID > DuidPtr
boost::shared_ptr< Lease6 > Lease6Ptr
Pointer to a Lease6 structure.
std::vector< Lease6Ptr > Lease6Collection
A collection of IPv6 leases.
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< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
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.
boost::shared_ptr< ClientId > ClientIdPtr
Shared pointer to a Client ID.
boost::shared_ptr< const CfgSubnets4 > ConstCfgSubnets4Ptr
Const pointer.
boost::shared_ptr< const CfgSubnets6 > ConstCfgSubnets6Ptr
Const pointer.
boost::shared_ptr< Lease6Collection > Lease6CollectionPtr
A shared pointer to the collection of IPv6 leases.
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
std::vector< Lease4Ptr > Lease4Collection
A collection of IPv4 leases.
boost::shared_ptr< Lease4 > Lease4Ptr
Pointer to a Lease4 structure.
const int LEASE_CMDS_DBG_COMMAND_DATA
Logging level used to log successful commands.
isc::log::Logger lease_cmds_logger("lease-cmds-hooks")
boost::shared_ptr< BindingVariableMgr > BindingVariableMgrPtr
Defines a shared pointer to a BindingVariableMgr.
Defines the logger used by the top-level component of kea-lfc.
Hardware type that represents information from DHCPv4 packet.
static HWAddr fromText(const std::string &text, const uint16_t htype=HTYPE_ETHER)
Creates instance of the hardware address from textual format.
Structure that holds a lease for IPv6 address and/or prefix.
@ ACTION_UPDATE
update extended info tables.
a common structure for IPv4 and IPv6 leases
Type
Type of lease or pool.
@ TYPE_TA
the lease contains temporary IPv6 address
@ TYPE_PD
the lease contains IPv6 prefix (for prefix delegation)
@ TYPE_NA
the lease contains non-temporary IPv6 address
static void syncCurrentExpirationTime(const Lease &from, Lease &to)
Sync lease current expiration time with new value from another lease, so that additional operations c...
static std::string typeToText(Type type)
returns text representation of a lease type