8#include <kea_version.h> 
  114#include <boost/foreach.hpp> 
  115#include <boost/pointer_cast.hpp> 
  116#include <boost/range/adaptor/reversed.hpp> 
  117#include <boost/shared_ptr.hpp> 
  131namespace ph = std::placeholders;
 
  137    int hook_index_buffer4_receive_;        
 
  138    int hook_index_pkt4_receive_;           
 
  139    int hook_index_subnet4_select_;         
 
  140    int hook_index_leases4_committed_;      
 
  141    int hook_index_lease4_release_;         
 
  142    int hook_index_pkt4_send_;              
 
  143    int hook_index_buffer4_send_;           
 
  144    int hook_index_lease4_decline_;         
 
  145    int hook_index_host4_identifier_;       
 
  146    int hook_index_ddns4_update_;           
 
  147    int hook_index_lease4_offer_;           
 
  148    int hook_index_lease4_server_decline_;  
 
  169std::set<std::string> dhcp4_statistics = {
 
  171    "pkt4-discover-received",
 
  172    "pkt4-offer-received",
 
  173    "pkt4-request-received",
 
  176    "pkt4-release-received",
 
  177    "pkt4-decline-received",
 
  178    "pkt4-inform-received",
 
  179    "pkt4-unknown-received",
 
  186    "v4-allocation-fail",
 
  187    "v4-allocation-fail-shared-network",
 
  188    "v4-allocation-fail-subnet",
 
  189    "v4-allocation-fail-no-pools",
 
  190    "v4-allocation-fail-classes",
 
  191    "v4-reservation-conflicts",
 
  211    : alloc_engine_(alloc_engine), query_(query), resp_(),
 
  212      context_(context), ipv6_only_preferred_(false) {
 
  214    if (!alloc_engine_) {
 
  216                  " when creating an instance of the Dhcpv4Exchange");
 
  221                  " creating an instance of the Dhcpv4Exchange");
 
  230    context_->subnet_ = subnet;
 
  236    if (subnet && !context_->early_global_reservations_lookup_) {
 
  239            context_->clientid_.reset(
new ClientId(opt_clientid->getData()));
 
  245        if (subnet->getReservationsInSubnet() ||
 
  246            subnet->getReservationsGlobal()) {
 
  249            if (!context_->early_global_reservations_lookup_) {
 
  254            alloc_engine->findReservation(*context_);
 
  257            subnet->getSharedNetwork(sn);
 
  267    auto global_host = context_->globalHost();
 
  268    auto current_host = context_->currentHost();
 
  269    if ((!context_->early_global_reservations_lookup_ &&
 
  270         global_host && !global_host->getClientClasses4().empty()) ||
 
  271        (!sn && current_host && !current_host->getClientClasses4().empty())) {
 
  292    if (!context_->hosts_.empty()) {
 
  293        query->addClass(
"KNOWN");
 
  295            .arg(query->getLabel())
 
  298        query->addClass(
"UNKNOWN");
 
  300            .arg(query->getLabel())
 
  309        .arg(query_->getLabel())
 
  313    if (query_->inClass(
"DROP")) {
 
  315            .arg(query_->getHWAddrLabel())
 
  316            .arg(query_->toText());
 
  318                                                  static_cast<int64_t
>(1));
 
 
  325    uint8_t resp_type = 0;
 
  339        resp_.reset(
new Pkt4(resp_type, 
getQuery()->getTransid()));
 
  341        copyDefaultOptions();
 
 
  355    const Pkt6Ptr& query6 = query->getPkt6();
 
  359    if (!query6->relay_info_.empty()) {
 
  360        resp6->copyRelayInfo(query6);
 
  363    resp6->setIface(query6->getIface());
 
  364    resp6->setIndex(query6->getIndex());
 
  365    resp6->setRemoteAddr(query6->getRemoteAddr());
 
  366    resp6->setRemotePort(query6->getRemotePort());
 
  367    resp_.reset(
new Pkt4o6(resp_, resp6));
 
 
  371Dhcpv4Exchange::copyDefaultFields() {
 
  372    resp_->setIface(query_->getIface());
 
  373    resp_->setIndex(query_->getIndex());
 
  380        resp_->setCiaddr(query_->getCiaddr());
 
  384    resp_->setHops(query_->getHops());
 
  387    resp_->setHWAddr(query_->getHWAddr());
 
  390    resp_->setGiaddr(query_->getGiaddr());
 
  399    HWAddrPtr src_hw_addr = query_->getLocalHWAddr();
 
  401        resp_->setLocalHWAddr(src_hw_addr);
 
  403    HWAddrPtr dst_hw_addr = query_->getRemoteHWAddr();
 
  405        resp_->setRemoteHWAddr(dst_hw_addr);
 
  409    resp_->setFlags(query_->getFlags());
 
  413Dhcpv4Exchange::copyDefaultOptions() {
 
  418    if (client_id && echo) {
 
  419        resp_->addOption(client_id);
 
  432        resp_->addOption(subnet_sel);
 
  445        sao->boolValue() && query_->inClass(
"STASH_AGENT_OPTIONS")) {
 
  448    resp_->addOption(rai);
 
  458    for (
auto const& id_type : cfg->getIdentifierTypes()) {
 
  461            if (context->hwaddr_ && !context->hwaddr_->hwaddr_.empty()) {
 
  462                context->addHostIdentifier(id_type, context->hwaddr_->hwaddr_);
 
  467            if (context->clientid_) {
 
  468                const std::vector<uint8_t>& vec = context->clientid_->getClientId();
 
  473                    if ((vec[0] == CLIENT_ID_OPTION_TYPE_DUID) && (vec.size() > 5)) {
 
  475                        context->addHostIdentifier(id_type,
 
  476                                                   std::vector<uint8_t>(vec.begin() + 5,
 
  488                    if (circuit_id_opt) {
 
  489                        const OptionBuffer& circuit_id_vec = circuit_id_opt->getData();
 
  490                        if (!circuit_id_vec.empty()) {
 
  491                            context->addHostIdentifier(id_type, circuit_id_vec);
 
  499            if (context->clientid_) {
 
  500                const std::vector<uint8_t>& vec = context->clientid_->getClientId();
 
  502                    context->addHostIdentifier(id_type, vec);
 
  515                std::vector<uint8_t> id;
 
  524                callout_handle->setArgument(
"query4", context->query_);
 
  525                callout_handle->setArgument(
"id_type", type);
 
  526                callout_handle->setArgument(
"id_value", 
id);
 
  532                callout_handle->getArgument(
"id_type", type);
 
  533                callout_handle->getArgument(
"id_value", 
id);
 
  539                        .arg(context->query_->getLabel())
 
  542                    context->addHostIdentifier(type, 
id);
 
 
  557    for (
auto const& def : *defs_ptr) {
 
  561        if (def->getMatchExpr()) {
 
  562            query->classes_.erase(def->getName());
 
 
  569    if (context->currentHost() && context->query_) {
 
  570        const ClientClasses& classes = context->currentHost()->getClientClasses4();
 
  571        for (
auto const& cclass : classes) {
 
  572            context->query_->addClass(cclass);
 
 
  579    if (context_->subnet_) {
 
  581        context_->subnet_->getSharedNetwork(shared_network);
 
  582        if (shared_network) {
 
  584            if (host && (host->getIPv4SubnetID() != SUBNET_ID_GLOBAL)) {
 
 
  596        if (!host->getNextServer().isV4Zero()) {
 
  597            resp_->setSiaddr(host->getNextServer());
 
  600        std::string sname = host->getServerHostname();
 
  601        if (!sname.empty()) {
 
  602            resp_->setSname(
reinterpret_cast<const uint8_t*
>(sname.c_str()),
 
  606        std::string bootfile = host->getBootFileName();
 
  607        if (!bootfile.empty()) {
 
  608            resp_->setFile(
reinterpret_cast<const uint8_t*
>(bootfile.c_str()),
 
 
  616    boost::shared_ptr<OptionString> vendor_class =
 
 
  628    pkt->addClass(
"ALL");
 
 
  642    for (
auto const& it : *defs_ptr) {
 
  650        if (it->getAdditional()) {
 
  654        if (it->getDependOnKnown() != depend_on_known) {
 
  657        it->test(pkt, expr_ptr);
 
 
  664                     const bool use_bcast, 
const bool direct_response_desired)
 
  670      test_send_responses_to_source_(false) {
 
  672    const char* env = std::getenv(
"KEA_TEST_SEND_RESPONSES_TO_SOURCE");
 
  675        test_send_responses_to_source_ = 
true;
 
  703    } 
catch (
const std::exception &e) {
 
 
  719    for (
auto const& it : dhcp4_statistics) {
 
  721        stats_mgr.
setValue(it, 
static_cast<int64_t
>(0));
 
 
  731    } 
catch (
const std::exception& ex) {
 
  738    } 
catch (
const std::exception& ex) {
 
  757        if (!names.empty()) {
 
  759            for (
size_t i = 1; i < names.size(); ++i) {
 
  760                msg += std::string(
", ") + names[i];
 
  766    io_service_->stopAndPoll();
 
 
  777                        bool sanity_only, 
bool allow_answer_park) {
 
  780    if (query->isDhcp4o6()) {
 
  789    subnet = cfgmgr.
getCurrentCfg()->getCfgSubnets4()->selectSubnet(selector);
 
  801        shared_ptr<ScopedCalloutHandleState> callout_handle_state(
 
  802            std::make_shared<ScopedCalloutHandleState>(callout_handle));
 
  808        callout_handle->setArgument(
"query4", query);
 
  809        callout_handle->setArgument(
"subnet4", subnet);
 
  810        callout_handle->setArgument(
"subnet4collection",
 
  812                                    getCfgSubnets4()->getAll());
 
  814        auto const tpl(parkingLimitExceeded(
"subnet4_select"));
 
  815        bool const exceeded(
get<0>(tpl));
 
  817            uint32_t 
const limit(
get<1>(tpl));
 
  822                .arg(query->getLabel());
 
  828            "subnet4_select", query, [
this, query, allow_answer_park, callout_handle_state]() {
 
  830                    boost::shared_ptr<function<void()>> callback(
 
  831                        boost::make_shared<function<
void()>>(
 
  832                            [
this, query, allow_answer_park]() 
mutable {
 
  835                    callout_handle_state->on_completion_ = [callback]() {
 
  858                .arg(query->getLabel());
 
  871                .arg(query->getLabel());
 
  880                .arg(query->getLabel());
 
  886        callout_handle->getArgument(
"subnet4", subnet);
 
  892            .arg(query->getLabel())
 
  893            .arg(subnet->getID());
 
  897            .arg(query->getLabel())
 
  898            .arg(subnet->toText());
 
  903            .arg(query->getLabel());
 
 
  911                           bool sanity_only, 
bool allow_answer_park) {
 
  915    selector.
ciaddr_ = query->getCiaddr();
 
  916    selector.
giaddr_ = query->getGiaddr();
 
  927    Pkt4o6Ptr query4o6 = boost::dynamic_pointer_cast<Pkt4o6>(query);
 
  931    const Pkt6Ptr& query6 = query4o6->getPkt6();
 
  934    if (query6 && !query6->relay_info_.empty()) {
 
  935        for (
auto const& relay : boost::adaptors::reverse(query6->relay_info_)) {
 
  936            if (!relay.linkaddr_.isV6Zero() &&
 
  937                !relay.linkaddr_.isV6LinkLocal()) {
 
  950        OptionCustomPtr oc = boost::dynamic_pointer_cast<OptionCustom>(sbnsel);
 
  957    subnet = cfgmgr.
getCurrentCfg()->getCfgSubnets4()->selectSubnet4o6(selector);
 
  969        shared_ptr<ScopedCalloutHandleState> callout_handle_state(
 
  970            std::make_shared<ScopedCalloutHandleState>(callout_handle));
 
  976        callout_handle->setArgument(
"query4", query);
 
  977        callout_handle->setArgument(
"subnet4", subnet);
 
  978        callout_handle->setArgument(
"subnet4collection",
 
  980                                    getCfgSubnets4()->getAll());
 
  982        auto const tpl(parkingLimitExceeded(
"subnet4_select"));
 
  983        bool const exceeded(
get<0>(tpl));
 
  985            uint32_t 
const limit(
get<1>(tpl));
 
  990                .arg(query->getLabel());
 
  996            "subnet4_select", query, [
this, query, allow_answer_park, callout_handle_state]() {
 
  998                    boost::shared_ptr<function<void()>> callback(
 
  999                        boost::make_shared<function<
void()>>(
 
 1000                            [
this, query, allow_answer_park]() 
mutable {
 
 1003                    callout_handle_state->on_completion_ = [callback]() {
 
 1026                .arg(query->getLabel());
 
 1039                .arg(query->getLabel());
 
 1048                .arg(query->getLabel());
 
 1054        callout_handle->getArgument(
"subnet4", subnet);
 
 1061            .arg(query->getLabel())
 
 1062            .arg(subnet->getID());
 
 1067            .arg(query->getLabel())
 
 1068            .arg(subnet->toText());
 
 1073            .arg(query->getLabel());
 
 
 1093    ctx->query_ = query;
 
 1096    ctx->hwaddr_ = query->getHWAddr();
 
 
 1110        ctx->early_global_reservations_lookup_ = egrl->boolValue();
 
 1114    if (ctx->early_global_reservations_lookup_) {
 
 1118            ctx->clientid_.reset(
new ClientId(opt_clientid->getData()));
 
 1127        if (global_host && !global_host->getClientClasses4().empty()) {
 
 1132            const ClientClasses& classes = global_host->getClientClasses4();
 
 1133            for (
auto const& cclass : classes) {
 
 1134                query->addClass(cclass);
 
 1143            query->addClass(
"KNOWN");
 
 1145                .arg(query->getLabel())
 
 1152            if (query->inClass(
"DROP")) {
 
 1155                    .arg(query->getHWAddrLabel())
 
 1156                    .arg(query->toText());
 
 1158                                                          static_cast<int64_t
>(1));
 
 1163            ctx->hosts_[SUBNET_ID_GLOBAL] = global_host;
 
 
 1177    const char* 
interface = getenv(
"KEA_AFL_INTERFACE");
 
 1179        isc_throw(FuzzInitFail, 
"no fuzzing interface has been set");
 
 1183    const char* address = getenv(
"KEA_AFL_ADDRESS");
 
 1185        isc_throw(FuzzInitFail, 
"no fuzzing address has been set");
 
 1193    while (__AFL_LOOP(fuzzer.maxLoopCount())) {
 
 1205        } 
catch (
const std::exception& e) {
 
 
 1236        uint32_t timeout = 1;
 
 1247                .arg(query->getRemoteAddr().toText())
 
 1248                .arg(query->getRemotePort())
 
 1249                .arg(query->getLocalAddr().toText())
 
 1250                .arg(query->getLocalPort())
 
 1251                .arg(query->getIface());
 
 1267    } 
catch (
const std::exception& e) {
 
 1283            .arg(query->getLabel());
 
 1287            query->addPktEvent(
"mt_queued");
 
 1288            typedef function<void()> CallBack;
 
 1289            boost::shared_ptr<CallBack> call_back =
 
 
 1305    } 
catch (
const std::exception& e) {
 
 1307            .arg(query->getLabel())
 
 
 1328    query->addPktEvent(
"process_started");
 
 1331    query->addClass(
"ALL");
 
 1338                                              static_cast<int64_t
>(1));
 
 1340    bool skip_unpack = 
false;
 
 1357        callout_handle->setArgument(
"query4", query);
 
 1369                .arg(query->getRemoteAddr().toText())
 
 1370                .arg(query->getLocalAddr().toText())
 
 1371                .arg(query->getIface());
 
 1382                .arg(query->getRemoteAddr().toText())
 
 1383                .arg(query->getLocalAddr().toText())
 
 1384                .arg(query->getIface());
 
 1388        callout_handle->getArgument(
"query4", query);
 
 1396                .arg(query->getRemoteAddr().toText())
 
 1397                .arg(query->getLocalAddr().toText())
 
 1398                .arg(query->getIface());
 
 1405                .arg(query->getLabel())
 
 1407        } 
catch (
const std::exception& e) {
 
 1410                .arg(query->getLabel())
 
 1411                .arg(query->getRemoteAddr().toText())
 
 1412                .arg(query->getLocalAddr().toText())
 
 1413                .arg(query->getIface())
 
 1415                .arg(query->getHWAddrLabel());
 
 1419                                                      static_cast<int64_t
>(1));
 
 1421                                                      static_cast<int64_t
>(1));
 
 1428        .arg(query->getLabel());
 
 1436    } 
catch (
const std::exception&) {
 
 1453                                                  static_cast<int64_t
>(1));
 
 1459    int type = query->getType();
 
 1461        .arg(query->getLabel())
 
 1462        .arg(query->getName())
 
 1464        .arg(query->getRemoteAddr())
 
 1465        .arg(query->getLocalAddr())
 
 1466        .arg(query->getIface());
 
 1468        .arg(query->getLabel())
 
 1469        .arg(query->toText());
 
 1485        callout_handle->setArgument(
"query4", query);
 
 1498                .arg(query->getLabel());
 
 1502        callout_handle->getArgument(
"query4", query);
 
 1506    if (query->inClass(
"DROP")) {
 
 1508            .arg(query->getHWAddrLabel())
 
 1509            .arg(query->toText());
 
 1511                                                  static_cast<int64_t
>(1));
 
 
 1520                                            bool allow_answer_park) {
 
 1529    } 
catch (
const std::exception& e) {
 
 1531            .arg(query->getLabel())
 
 
 1551                                       this, query, allow_answer_park));
 
 1552        if (!client_handler.
tryLock(query, cont)) {
 
 1568            ctx->subnet_ = 
selectSubnet(query, drop, 
false, allow_answer_park);
 
 1574    } 
catch (
const std::exception& e) {
 
 1584            .arg(query->getLabel())
 
 1589                                                  static_cast<int64_t
>(1));
 
 
 1598                                                 bool allow_answer_park) {
 
 1608    } 
catch (
const std::exception& e) {
 
 1610            .arg(query->getLabel())
 
 
 1619                                                 bool allow_answer_park) {
 
 1627        callout_handle->getContext(
"subnet4", ctx->subnet_);
 
 
 1637                                  bool allow_answer_park) {
 
 1644        switch (query->getType()) {
 
 1674    } 
catch (
const std::exception& e) {
 
 1684            .arg(query->getLabel())
 
 1689                                                  static_cast<int64_t
>(1));
 
 1696        int hook_idx = 
Hooks.hook_index_leases4_committed_;
 
 1697        std::string hook_label = 
"leases4_committed";
 
 1701        if (ctx->fake_allocation_) {
 
 1702            hook_idx = 
Hooks.hook_index_lease4_offer_;
 
 1703            hook_label = 
"lease4_offer";
 
 1733            std::shared_ptr<ScopedCalloutHandleState> callout_handle_state =
 
 1734                std::make_shared<ScopedCalloutHandleState>(callout_handle);
 
 1739            callout_handle->setArgument(
"query4", query);
 
 1743            callout_handle->setArgument(
"response4", rsp);
 
 1747            if (ctx->new_lease_ && (ctx->new_lease_->reuseable_valid_lft_ == 0)) {
 
 1748                new_leases->push_back(ctx->new_lease_);
 
 1750            callout_handle->setArgument(
"leases4", new_leases);
 
 1752            if (ctx->fake_allocation_) {
 
 1754                callout_handle->setArgument(
"offer_lifetime", ctx->offer_lft_);
 
 1755                callout_handle->setArgument(
"old_lease", ctx->old_lease_);
 
 1756                callout_handle->setArgument(
"host", ctx->currentHost());
 
 1760                if (ctx->old_lease_) {
 
 1761                    if ((!ctx->new_lease_) || (ctx->new_lease_->addr_ != ctx->old_lease_->addr_)) {
 
 1762                            deleted_leases->push_back(ctx->old_lease_);
 
 1765                callout_handle->setArgument(
"deleted_leases4", deleted_leases);
 
 1768            if (allow_answer_park) {
 
 1769                auto const tpl(parkingLimitExceeded(hook_label));
 
 1770                bool const exceeded(
get<0>(tpl));
 
 1772                    uint32_t 
const limit(
get<1>(tpl));
 
 1776                        .arg(query->getLabel());
 
 1778                                                                static_cast<int64_t
>(1));
 
 1788                    [
this, callout_handle, query, rsp, callout_handle_state, hook_idx, ctx]() 
mutable {
 
 1789                        if (hook_idx == 
Hooks.hook_index_lease4_offer_) {
 
 1790                            bool offer_address_in_use = 
false;
 
 1792                                callout_handle->getArgument(
"offer_address_in_use", offer_address_in_use);
 
 1795                                          .arg(query->getLabel())
 
 1799                            if (offer_address_in_use) {
 
 1801                                bool lease_exists = (ctx->offer_lft_ > 0);
 
 1803                                    typedef function<void()> CallBack;
 
 1806                                    boost::shared_ptr<CallBack> call_back = boost::make_shared<CallBack>(
 
 1808                                                  callout_handle, query, lease, lease_exists));
 
 1809                                    callout_handle_state->on_completion_ = [call_back]() {
 
 1822                            typedef function<void()> CallBack;
 
 1823                            boost::shared_ptr<CallBack> call_back = boost::make_shared<CallBack>(
 
 1825                                          query, rsp, ctx->subnet_));
 
 1826                            callout_handle_state->on_completion_ = [call_back]() {
 
 1841                if (allow_answer_park) {
 
 1849                allow_answer_park) {
 
 1851                    .arg(query->getLabel());
 
 1862                        .arg(query->getLabel());
 
 
 1884        } 
catch (
const std::exception& e) {
 
 1886                .arg(query->getLabel())
 
 
 1897    query->addPktEvent(
"process_completed");
 
 1903    bool skip_pack = 
false;
 
 1919        callout_handle->setArgument(
"query4", query);
 
 1922        callout_handle->setArgument(
"response4", rsp);
 
 1925        callout_handle->setArgument(
"subnet4", subnet);
 
 1938                .arg(query->getLabel());
 
 1945                .arg(rsp->getLabel());
 
 1954                .arg(rsp->getLabel());
 
 1956        } 
catch (
const std::exception& e) {
 
 1958                .arg(rsp->getLabel())
 
 
 1988            callout_handle->setArgument(
"response4", rsp);
 
 2001                    .arg(rsp->getLabel());
 
 2005            callout_handle->getArgument(
"response4", rsp);
 
 2009            .arg(rsp->getLabel())
 
 2010            .arg(rsp->getName())
 
 2011            .arg(
static_cast<int>(rsp->getType()))
 
 2012            .arg(rsp->getLocalAddr().isV4Zero() ? 
"*" : rsp->getLocalAddr().toText())
 
 2013            .arg(rsp->getLocalPort())
 
 2014            .arg(rsp->getRemoteAddr())
 
 2015            .arg(rsp->getRemotePort())
 
 2016            .arg(rsp->getIface().empty() ? 
"to be determined from routing" :
 
 2021            .arg(rsp->getLabel())
 
 2022            .arg(rsp->getName())
 
 2023            .arg(
static_cast<int>(rsp->getType()))
 
 2024            .arg(rsp->toText());
 
 2030    } 
catch (
const std::exception& e) {
 
 2032            .arg(rsp->getLabel())
 
 
 2042    boost::shared_ptr<Option4AddrLst> generated =
 
 2043        boost::dynamic_pointer_cast<Option4AddrLst>(srvid);
 
 2049    if (addrs.size() != 1) {
 
 2051                  << 
"Expected to contain a single IPv4 address.");
 
 2054    return (addrs[0].toText());
 
 
 2072    if (local_addr.
isV4Bcast() || query->isDhcp4o6()) {
 
 2078    opt_srvid->writeAddress(local_addr);
 
 
 2096    if (host && !host->getCfgOption4()->empty()) {
 
 2097        co_list.push_back(host->getCfgOption4());
 
 2104        addr = resp->getYiaddr();
 
 2108        if (pool && !pool->getCfgOption()->empty()) {
 
 2109            co_list.push_back(pool->getCfgOption());
 
 2114    if (!subnet->getCfgOption()->empty()) {
 
 2115        co_list.push_back(subnet->getCfgOption());
 
 2120    subnet->getSharedNetwork(network);
 
 2121    if (network && !network->getCfgOption()->empty()) {
 
 2122        co_list.push_back(network->getCfgOption());
 
 2127    for (
auto const& cclass : classes) {
 
 2130            getClientClassDictionary()->findClass(cclass);
 
 2142        if (ccdef->getCfgOption()->empty()) {
 
 2147        co_list.push_back(ccdef->getCfgOption());
 
 
 2171    if (co_list.empty()) {
 
 2177    set<uint8_t> requested_opts;
 
 2186        for (uint16_t code : option_prl->getValues()) {
 
 2187            static_cast<void>(requested_opts.insert(code));
 
 2191    std::set<uint8_t> cancelled_opts;
 
 2192    const auto& cclasses = query->getClasses();
 
 2196    for (
auto const& copts : co_list) {
 
 2204        BOOST_FOREACH(
auto const& desc, prange) {
 
 2207                uint8_t code = 
static_cast<uint8_t
>(desc.option_->getType());
 
 2208                static_cast<void>(requested_opts.insert(code));
 
 2214        BOOST_FOREACH(
auto const& desc, crange) {
 
 2217                uint8_t code = 
static_cast<uint8_t
>(desc.option_->getType());
 
 2218                static_cast<void>(cancelled_opts.insert(code));
 
 2225    for (uint8_t opt : requested_opts) {
 
 2226        if (cancelled_opts.count(opt) > 0) {
 
 2234        if (!resp->getOption(opt)) {
 
 2236            for (
auto const& copts : co_list) {
 
 2241                    resp->addOption(desc.
option_);
 
 2254        set<uint32_t> vendor_ids;
 
 2258            vendor_opts = boost::dynamic_pointer_cast<OptionVendorClass>(opt.second);
 
 2260                uint32_t vendor_id = vendor_opts->getVendorId();
 
 2261                static_cast<void>(vendor_ids.insert(vendor_id));
 
 2265        for (
auto const& copts : co_list) {
 
 2268                if (!desc.option_ || !desc.allowedForClientClasses(cclasses)) {
 
 2272                    boost::dynamic_pointer_cast<OptionVendorClass>(desc.option_);
 
 2277                uint32_t vendor_id = vendor_opts->getVendorId();
 
 2278                if (vendor_ids.count(vendor_id) > 0) {
 
 2282                resp->Pkt::addOption(desc.option_);
 
 2283                static_cast<void>(vendor_ids.insert(vendor_id));
 
 2292        set<uint32_t> vendor_ids;
 
 2296            vendor_opts = boost::dynamic_pointer_cast<OptionVendor>(opt.second);
 
 2298                uint32_t vendor_id = vendor_opts->getVendorId();
 
 2299                static_cast<void>(vendor_ids.insert(vendor_id));
 
 2303        for (
auto const& copts : co_list) {
 
 2306                if (!desc.option_ || !desc.allowedForClientClasses(cclasses)) {
 
 2310                    boost::dynamic_pointer_cast<OptionVendor>(desc.option_);
 
 2315                uint32_t vendor_id = vendor_opts->getVendorId();
 
 2316                if (vendor_ids.count(vendor_id) > 0) {
 
 2322                resp->Pkt::addOption(vendor_opts);
 
 2323                static_cast<void>(vendor_ids.insert(vendor_id));
 
 
 2343    if (!subnet || co_list.empty()) {
 
 2349    set<uint32_t> vendor_ids;
 
 2353    map<uint32_t, OptionVendorPtr> vendor_rsps;
 
 2356        vendor_rsp = boost::dynamic_pointer_cast<OptionVendor>(opt.second);
 
 2358            uint32_t vendor_id = vendor_rsp->getVendorId();
 
 2359            vendor_rsps[vendor_id] = vendor_rsp;
 
 2360            static_cast<void>(vendor_ids.insert(vendor_id));
 
 2366    map<uint32_t, OptionVendorPtr> vendor_reqs;
 
 2369        vendor_req = boost::dynamic_pointer_cast<OptionVendor>(opt.second);
 
 2371            uint32_t vendor_id = vendor_req->getVendorId();
 
 2372            vendor_reqs[vendor_id] = vendor_req;
 
 2373            static_cast<void>(vendor_ids.insert(vendor_id));
 
 2381        vendor_class = boost::dynamic_pointer_cast<OptionVendorClass>(opt.second);
 
 2383            uint32_t vendor_id = vendor_class->getVendorId();
 
 2384            static_cast<void>(vendor_ids.insert(vendor_id));
 
 2390    if (vendor_ids.empty()) {
 
 2394    map<uint32_t, set<uint8_t> > requested_opts;
 
 2408            oro = boost::dynamic_pointer_cast<OptionUint8Array>(oro_generic);
 
 2411            set<uint8_t> oro_req_opts;
 
 2412            for (uint8_t code : oro->getValues()) {
 
 2413                static_cast<void>(oro_req_opts.insert(code));
 
 2419    const auto& cclasses = query->getClasses();
 
 2420    for (uint32_t vendor_id : vendor_ids) {
 
 2422        std::set<uint8_t> cancelled_opts;
 
 2426        for (
auto const& copts : co_list) {
 
 2435            BOOST_FOREACH(
auto const& desc, prange) {
 
 2438                    uint8_t code = 
static_cast<uint8_t
>(desc.option_->getType());
 
 2439                    static_cast<void>(requested_opts[vendor_id].insert(code));
 
 2446            BOOST_FOREACH(
auto const& desc, crange) {
 
 2449                    uint8_t code = 
static_cast<uint8_t
>(desc.option_->getType());
 
 2450                    static_cast<void>(cancelled_opts.insert(code));
 
 2460        if (requested_opts[vendor_id].empty()) {
 
 2468        if (vendor_rsps.count(vendor_id) > 0) {
 
 2469            vendor_rsp = vendor_rsps[vendor_id];
 
 2477        for (uint8_t opt : requested_opts[vendor_id]) {
 
 2478            if (cancelled_opts.count(opt) > 0) {
 
 2481            if (!vendor_rsp->getOption(opt)) {
 
 2482                for (
auto const& copts : co_list) {
 
 2486                        vendor_rsp->addOption(desc.
option_);
 
 2496        if (added && (vendor_rsps.count(vendor_id) == 0)) {
 
 2497            resp->Pkt::addOption(vendor_rsp);
 
 
 2506    static const std::vector<uint16_t> required_options = {
 
 2520    if (co_list.empty()) {
 
 2525    const auto& cclasses = ex.
getQuery()->getClasses();
 
 2529    for (
auto const& required : required_options) {
 
 2530        OptionPtr opt = resp->getOption(required);
 
 2533            for (
auto const& copts : co_list) {
 
 2535                                                                       required, cclasses);
 
 2537                    resp->addOption(desc.
option_);
 
 
 2557                .arg(query->getLabel());
 
 2558            processClientFqdnOption(ex);
 
 2563                    .arg(query->getLabel());
 
 2564            processHostnameOption(ex);
 
 2570        std::string hostname;
 
 2571        bool fqdn_fwd = 
false;
 
 2572        bool fqdn_rev = 
false;
 
 2575        fqdn = boost::dynamic_pointer_cast<Option4ClientFqdn>(resp->getOption(
DHO_FQDN));
 
 2577            hostname = fqdn->getDomainName();
 
 2580            opt_hostname = boost::dynamic_pointer_cast<OptionString>
 
 2584                hostname = opt_hostname->getValue();
 
 2589                if (hostname == 
".") {
 
 2595                if (ex.
getContext()->getDdnsParams()->getEnableUpdates()) {
 
 2615            callout_handle->setArgument(
"query4", query);
 
 2616            callout_handle->setArgument(
"response4", resp);
 
 2617            callout_handle->setArgument(
"subnet4", subnet);
 
 2618            callout_handle->setArgument(
"hostname", hostname);
 
 2619            callout_handle->setArgument(
"fwd-update", fqdn_fwd);
 
 2620            callout_handle->setArgument(
"rev-update", fqdn_rev);
 
 2621            callout_handle->setArgument(
"ddns-params", ex.
getContext()->getDdnsParams());
 
 2627            string hook_hostname;
 
 2628            bool hook_fqdn_fwd = 
false;
 
 2629            bool hook_fqdn_rev = 
false;
 
 2630            callout_handle->getArgument(
"hostname", hook_hostname);
 
 2631            callout_handle->getArgument(
"fwd-update", hook_fqdn_fwd);
 
 2632            callout_handle->getArgument(
"rev-update", hook_fqdn_rev);
 
 2636            if ((hostname != hook_hostname) || (fqdn_fwd != hook_fqdn_fwd) ||
 
 2637                (fqdn_rev != hook_fqdn_rev)) {
 
 2639                    .arg(hostname).arg(hook_hostname).arg(fqdn_fwd).arg(hook_fqdn_fwd)
 
 2640                    .arg(fqdn_rev).arg(hook_fqdn_rev);
 
 2641                hostname = hook_hostname;
 
 2642                fqdn_fwd = hook_fqdn_fwd;
 
 2643                fqdn_rev = hook_fqdn_rev;
 
 2647                OptionStringPtr hostname_opt = boost::dynamic_pointer_cast<OptionString>
 
 2650                    hostname_opt->setValue(hook_hostname);
 
 2655                fqdn = boost::dynamic_pointer_cast<Option4ClientFqdn>(resp->getOption(
DHO_FQDN));
 
 2667        ctx->fwd_dns_update_ = fqdn_fwd;
 
 2668        ctx->rev_dns_update_ = fqdn_rev;
 
 2669        ctx->hostname_ = hostname;
 
 
 2694        .arg(fqdn->toText());
 
 2710        !ex.
getContext()->currentHost()->getHostname().empty()) {
 
 2736        .arg(fqdn_resp->
toText());
 
 2741Dhcpv4Srv::processHostnameOption(Dhcpv4Exchange& ex) {
 
 2746    OptionStringPtr opt_hostname = boost::dynamic_pointer_cast<OptionString>
 
 2752            .arg(opt_hostname->getValue());
 
 2760    if (ctx->currentHost() && !ctx->currentHost()->getHostname().empty()) {
 
 2762        std::string hostname = d2_mgr.
qualifyName(ctx->currentHost()->getHostname(),
 
 2765        boost::algorithm::to_lower(hostname);
 
 2783        ex.
getContext()->getDdnsParams()->getReplaceClientNameMode();
 
 2786    if (!opt_hostname) {
 
 2806        .arg(opt_hostname->getValue());
 
 2809    unsigned int label_count;
 
 2815    } 
catch (
const std::exception& exc) {
 
 2826    if (label_count == 0) {
 
 2844        || label_count < 2) {
 
 2858            ex.
getContext()->getDdnsParams()->getHostnameSanitizer();
 
 2861            hostname = sanitizer->scrub(hostname);
 
 2865        boost::algorithm::to_lower(hostname);
 
 2867        if (label_count == 2) {
 
 2875            opt_hostname_resp.reset(
 
 2886        .arg(opt_hostname_resp->getValue());
 
 2896                  "NULL lease specified when creating NameChangeRequest");
 
 2904    if ((lease->reuseable_valid_lft_ == 0) &&
 
 2906         !lease->hasIdenticalFqdn(*old_lease))) {
 
 
 2924    while (current_subnet) {
 
 2930                subnet = current_subnet;
 
 2934        current_subnet = current_subnet->getNextSubnet(subnet, client_classes);
 
 2938    subnet->getSharedNetwork(network);
 
 
 2970    bool fake_allocation = (query->getType() == 
DHCPDISCOVER);
 
 2976        auto const& requested_opts = option_prl->getValues();
 
 2977        if ((std::find(requested_opts.cbegin(), requested_opts.cend(),
 
 2981            ctx->subnet_ = subnet;
 
 2983            if (!fake_allocation) {
 
 2984                resp->setCiaddr(query->getCiaddr());
 
 3000    if (opt_requested_address) {
 
 3001        hint = opt_requested_address->readAddress();
 
 3003    } 
else if (!query->getCiaddr().isV4Zero()) {
 
 3004        hint = query->getCiaddr();
 
 3011    auto authoritative = 
false;
 
 3017    auto init_reboot = (!fake_allocation && !opt_serverid && opt_requested_address);
 
 3020            .arg(query->getLabel())
 
 3025            authoritative = subnet->getAuthoritative();
 
 3031                authoritative = flag->boolValue();
 
 3034    } 
else if (fake_allocation) {
 
 3036            .arg(query->getLabel())
 
 3040            .arg(query->getLabel())
 
 3048    if (!subnet && (!init_reboot || authoritative)) {
 
 3055            .arg(query->getLabel())
 
 3056            .arg(query->getRemoteAddr().toText())
 
 3057            .arg(query->getName());
 
 3075        auto const& classes = query->getClasses();
 
 3085        if (original_subnet && client_id) {
 
 3089            if (!leases_client_id.empty()) {
 
 3095                    for (
auto const& l : leases_client_id) {
 
 3096                        if (l->subnet_id_ == s->getID()) {
 
 3106                        s = s->getNextSubnet(original_subnet, classes);
 
 3114        if (original_subnet && !lease && hwaddr) {
 
 3118            if (!leases_hwaddr.empty()) {
 
 3123                    for (
auto const& l : leases_hwaddr) {
 
 3124                        if (l->subnet_id_ == s->getID()) {
 
 3134                        s = s->getNextSubnet(original_subnet, classes);
 
 3143        bool known_client = lease && lease->belongsToClient(hwaddr, client_id);
 
 3144        if (!authoritative && !known_client) {
 
 3147                .arg(query->getLabel())
 
 3156        if ((known_client && (lease->addr_ != hint)) ||
 
 3157            (!known_client && authoritative) ||
 
 3158            (!original_subnet)) {
 
 3161                .arg(query->getLabel())
 
 3173    ctx->requested_address_ = hint;
 
 3174    ctx->fake_allocation_ = fake_allocation;
 
 3175    ctx->callout_handle_ = callout_handle;
 
 3189    bool reprocess_client_name = 
false;
 
 3193        auto ddns_params = ex.
getContext()->getDdnsParams();
 
 3194        auto pool = ddns_params->setPoolFromAddress(lease->addr_);
 
 3196            reprocess_client_name = pool->hasDdnsParameters();
 
 3202    if (subnet && ctx->subnet_ && subnet->getID() != ctx->subnet_->getID()) {
 
 3211        subnet->getSharedNetwork(network);
 
 3213                .arg(query->getLabel())
 
 3214                .arg(subnet->toText())
 
 3215                .arg(ctx->subnet_->toText())
 
 3216                .arg(network ? network->getName() : 
"<no network?>");
 
 3218        subnet = ctx->subnet_;
 
 3220            reprocess_client_name = 
true;
 
 3226    bool client_name_changed = 
false;
 
 3228    if (reprocess_client_name) {
 
 3233        ctx->hostname_ = 
"";
 
 3234        ctx->fwd_dns_update_  = 
false;
 
 3235        ctx->rev_dns_update_ = 
false;
 
 3242        if ((lease->hostname_ != ctx->hostname_) ||
 
 3243            (lease->fqdn_fwd_ != ctx->fwd_dns_update_) ||
 
 3244            (lease->fqdn_rev_ != ctx->rev_dns_update_)) {
 
 3245            lease->hostname_ = ctx->hostname_;
 
 3246            lease->fqdn_fwd_ = ctx->fwd_dns_update_;
 
 3247            lease->fqdn_rev_ = ctx->rev_dns_update_;
 
 3248            client_name_changed = 
true;
 
 3255        if (fake_allocation) {
 
 3257                .arg(query->getLabel())
 
 3258                .arg(lease->addr_.toText());
 
 3261                .arg(query->getLabel())
 
 3262                .arg(lease->addr_.toText())
 
 3270        if (!ctx->subnet_->getMatchClientId()) {
 
 3272                .arg(ctx->query_->getLabel())
 
 3273                .arg(ctx->subnet_->getID());
 
 3276        resp->setYiaddr(lease->addr_);
 
 3282        if (!fake_allocation) {
 
 3287            resp->setCiaddr(query->getCiaddr());
 
 3296        if (lease->reuseable_valid_lft_ > 0) {
 
 3297            lease->valid_lft_ = lease->reuseable_valid_lft_;
 
 3299                .arg(query->getLabel())
 
 3300                .arg(lease->addr_.toText())
 
 3317        resp->addOption(opt);
 
 3320        resp->addOption(getNetmaskOption(subnet));
 
 3326        if (!fake_allocation) {
 
 3332                    .arg(query->getLabel())
 
 3340        if (ctx->unknown_requested_addr_) {
 
 3352                s = s->getNextSubnet(original_subnet);
 
 3360                          .arg(query->getLabel())
 
 3361                          .arg(query->getCiaddr().toText())
 
 3362                          .arg(opt_requested_address ?
 
 3363                          opt_requested_address->readAddress().toText() : 
"(no address)");
 
 3371            .arg(query->getLabel())
 
 3372            .arg(query->getCiaddr().toText())
 
 3373            .arg(opt_requested_address ?
 
 3374                 opt_requested_address->readAddress().toText() : 
"(no address)");
 
 
 3386                                 const Pkt4Ptr& query, 
const Pkt4Ptr& resp, 
bool client_name_changed) {
 
 3395        opt_hostname = boost::dynamic_pointer_cast<OptionString>(resp->getOption(
DHO_HOST_NAME));
 
 3396        if (!opt_hostname) {
 
 3403    if (lease->hostname_.empty()) {
 
 3410                    .
generateFqdn(lease->addr_, *(ctx->getDdnsParams()), 
static_cast<bool>(fqdn));
 
 3413            .arg(query->getLabel())
 
 3414            .arg(lease->hostname_);
 
 3416        client_name_changed = 
true;
 
 3419    if (client_name_changed) {
 
 3425            if (!ctx->fake_allocation_ || (ctx->offer_lft_ > 0)) {
 
 3427                lease->reuseable_valid_lft_ = 0;
 
 3440                opt_hostname->setValue(lease->hostname_);
 
 3444                .arg(query->getLabel())
 
 3445                .arg(lease->hostname_)
 
 
 3455    uint32_t t2_time = 0;
 
 3457    if (!subnet->getT2().unspecified()) {
 
 3458        t2_time = subnet->getT2();
 
 3459    } 
else if (subnet->getCalculateTeeTimes()) {
 
 3461        t2_time = 
static_cast<uint32_t
>(round(subnet->getT2Percent() * (lease->valid_lft_)));
 
 3466    uint32_t timer_ceiling = lease->valid_lft_;
 
 3467    if (t2_time > 0 && t2_time < timer_ceiling) {
 
 3469        resp->addOption(t2);
 
 3471        timer_ceiling = t2_time;
 
 3474    uint32_t t1_time = 0;
 
 3476    if (!subnet->getT1().unspecified()) {
 
 3477        t1_time = subnet->getT1();
 
 3478    } 
else if (subnet->getCalculateTeeTimes()) {
 
 3480        t1_time = 
static_cast<uint32_t
>(round(subnet->getT1Percent() * (lease->valid_lft_)));
 
 3485    if (t1_time > 0 && t1_time < timer_ceiling) {
 
 3487        resp->addOption(t1);
 
 
 3499        return (query->getRemotePort());
 
 
 3527    } 
else if (((query->getType() == 
DHCPINFORM) &&
 
 3528         ((!query->getCiaddr().isV4Zero()) ||
 
 3529          (!query->isRelayed() && !query->getRemoteAddr().isV4Zero()))) ||
 
 3530        ((query->getType() != 
DHCPINFORM) && !query->isRelayed())) {
 
 3531        response->setRemotePort(DHCP4_CLIENT_PORT);
 
 3536        response->setRemotePort(relay_port ? relay_port : DHCP4_SERVER_PORT);
 
 3540    if (query->isRelayed() &&
 
 3546        response->resetIndex();
 
 3548        response->setIface(query->getIface());
 
 3552        IOAddress local_addr = query->getLocalAddr();
 
 3561        if (local_addr.
isV4Bcast() || query->isDhcp4o6()) {
 
 3572        response->setLocalAddr(local_addr);
 
 3581        response->setIndex(query->getIndex());
 
 3582        response->setIface(query->getIface());
 
 3588        response->setLocalPort(DHCP4_SERVER_PORT);
 
 
 3600    if (query->isDhcp4o6()) {
 
 3601        response->setRemoteAddr(query->getRemoteAddr());
 
 3613        if (!query->getCiaddr().isV4Zero()) {
 
 3614            response->setRemoteAddr(query->getCiaddr());
 
 3621        } 
else if (query->isRelayed()) {
 
 3622            response->setRemoteAddr(query->getGiaddr());
 
 3623            response->setFlags(response->getFlags() | BOOTP_BROADCAST);
 
 3628            response->setRemoteAddr(query->getRemoteAddr());
 
 3635    if (query->isRelayed()) {
 
 3644            query->getCiaddr().isV4Zero()) {
 
 3645            response->setFlags(BOOTP_BROADCAST);
 
 3647        response->setRemoteAddr(query->getGiaddr());
 
 3651    } 
else if (!query->getCiaddr().isV4Zero()) {
 
 3652        response->setRemoteAddr(query->getCiaddr());
 
 3657    } 
else if (response->getType() == 
DHCPNAK) {
 
 3661    } 
else if (!response->getYiaddr().isV4Zero()) {
 
 3676            response->setRemoteAddr(response ->getYiaddr());
 
 3684        response->setRemoteAddr(query->getRemoteAddr());
 
 3689        response->setRemoteAddr(query->getRemoteAddr());
 
 
 3701        IOAddress subnet_next_server = subnet->getSiaddr();
 
 3702        if (!subnet_next_server.
isV4Zero()) {
 
 3703            response->setSiaddr(subnet_next_server);
 
 3706        const string& sname = subnet->getSname();
 
 3707        if (!sname.empty()) {
 
 3713            response->setSname(
reinterpret_cast<const uint8_t*
>(sname.c_str()),
 
 3717        const string& filename = subnet->getFilename();
 
 3718        if (!filename.empty()) {
 
 3724            response->setFile(
reinterpret_cast<const uint8_t*
>(filename.c_str()),
 
 3732    if (!classes.
empty()) {
 
 3745        size_t found_cnt = 0;  
 
 3746        for (
auto const& name : classes) {
 
 3748            if (found_cnt >= 3) {
 
 3762                next_server = cl->getNextServer();
 
 3764                    response->setSiaddr(next_server);
 
 3769            if (sname.empty()) {
 
 3770                sname = cl->getSname();
 
 3771                if (!sname.empty()) {
 
 3777                    response->setSname(
reinterpret_cast<const uint8_t*
>(sname.c_str()),
 
 3783            if (filename.empty()) {
 
 3784                filename = cl->getFilename();
 
 3785                if (!filename.empty()) {
 
 3791                    response->setFile(
reinterpret_cast<const uint8_t*
>(filename.c_str()),
 
 
 3814tuple<bool, uint32_t>
 
 3815Dhcpv4Srv::parkingLimitExceeded(
string const& hook_label) {
 
 3817    uint32_t parked_packet_limit(0);
 
 3821        parked_packet_limit = ppl->intValue();
 
 3824    if (parked_packet_limit) {
 
 3828        if (parking_lot && parked_packet_limit <= parking_lot->size()) {
 
 3829            return make_tuple(
true, parked_packet_limit);
 
 3832    return make_tuple(
false, parked_packet_limit);
 
 3870            .arg(discover->getLabel())
 
 3871            .arg(discover->getName())
 
 3872            .arg(discover->getClasses().toText());
 
 3881                    .arg(discover->getLabel());
 
 
 3940    } 
else if (request->inClass(
"BOOTP")) {
 
 3942        response->addClass(
"BOOTP");
 
 3956            .arg(request->getLabel())
 
 3957            .arg(request->getName())
 
 3958            .arg(request->getClasses().toText());
 
 3967                    .arg(request->getLabel());
 
 
 4020                .arg(release->getLabel())
 
 4021                .arg(release->getCiaddr().toText());
 
 4025        if (!lease->belongsToClient(release->getHWAddr(), client_id)) {
 
 4027                .arg(release->getLabel())
 
 4028                .arg(release->getCiaddr().toText());
 
 4048            callout_handle->setArgument(
"query4", release);
 
 4051            callout_handle->setArgument(
"lease4", lease);
 
 4065                    .arg(release->getLabel());
 
 4073            bool success = 
false; 
 
 4074            bool expired = 
false; 
 
 4078            if (expiration_cfg->getFlushReclaimedTimerWaitTime() &&
 
 4079                expiration_cfg->getHoldReclaimedTime() &&
 
 4082                lease->valid_lft_ = 0;
 
 4098                context->old_lease_ = lease;
 
 4102                    .arg(release->getLabel())
 
 4103                    .arg(lease->addr_.toText());
 
 4107                                            .arg(release->getLabel())
 
 4108                                            .arg(lease->addr_.toText());
 
 4111                        .arg(release->getLabel())
 
 4112                        .arg(lease->addr_.toText());
 
 4121                    static_cast<int64_t
>(-1));
 
 4125                    auto const& pool = subnet->getPool(
Lease::TYPE_V4, lease->addr_, 
false);
 
 4130                            static_cast<int64_t
>(-1));
 
 4137                    .arg(release->getLabel())
 
 4138                    .arg(lease->addr_.toText());
 
 4143            .arg(release->getLabel())
 
 4144            .arg(release->getCiaddr())
 
 
 4157    if (!opt_requested_address) {
 
 4160                  " in DHCPDECLINE sent from " << decline->getLabel());
 
 4162    IOAddress addr(opt_requested_address->readAddress());
 
 4180            .arg(addr.
toText()).arg(decline->getLabel());
 
 4188        client_id.reset(
new ClientId(opt_clientid->getData()));
 
 4197        !lease->belongsToClient(decline->getHWAddr(), client_id)) {
 
 4200        string client_hw = decline->getHWAddr() ?
 
 4201            decline->getHWAddr()->toText(
false) : 
"(none)";
 
 4202        string lease_hw = lease->hwaddr_ ?
 
 4203            lease->hwaddr_->toText(
false) : 
"(none)";
 
 4206        string client_id_txt = client_id ? client_id->toText() : 
"(none)";
 
 4207        string lease_id_txt = lease->client_id_ ?
 
 4208            lease->client_id_->toText() : 
"(none)";
 
 4212            .arg(addr.
toText()).arg(decline->getLabel())
 
 4213            .arg(client_hw).arg(lease_hw).arg(client_id_txt).arg(lease_id_txt);
 
 
 4243        callout_handle->setArgument(
"query4", decline);
 
 4246        callout_handle->setArgument(
"lease4", lease);
 
 4257                .arg(decline->getLabel()).arg(lease->addr_.toText());
 
 4262    Lease4Ptr old_values = boost::make_shared<Lease4>(*lease);
 
 4276            .arg(decline->getLabel())
 
 4277            .arg(lease->addr_.toText())
 
 4291        static_cast<int64_t
>(1));
 
 4295        auto const& pool = subnet->getPool(
Lease::TYPE_V4, lease->addr_, 
false);
 
 4300                static_cast<int64_t
>(1));
 
 4317    context->new_lease_ = lease;
 
 4320        .arg(decline->getLabel()).arg(lease->valid_lft_);
 
 
 4327            .arg(query->getLabel())
 
 4328            .arg(lease->addr_.toText())
 
 4329            .arg(lease->valid_lft_);
 
 4337                .arg(query->getLabel())
 
 4338                .arg(lease->addr_.toText());
 
 4354                lease_exists = 
false;
 
 4358                    .arg(query->getLabel())
 
 4359                    .arg(lease->addr_.toText());
 
 4364        if (!lease_exists) {
 
 4369                    .arg(query->getLabel())
 
 4370                    .arg(lease->addr_.toText());
 
 4387        static_cast<int64_t
>(1));
 
 4389    if (!lease_exists) {
 
 4392            static_cast<int64_t
>(1));
 
 4397        auto const& pool = subnet->getPool(
Lease::TYPE_V4, lease->addr_, 
false);
 
 4402                static_cast<int64_t
>(1));
 
 4403            if (!lease_exists) {
 
 4407                    static_cast<int64_t
>(1));
 
 4414    if (!lease_exists) {
 
 4428        callout_handle->setArgument(
"query4", query);
 
 4431        callout_handle->setArgument(
"lease4", lease);
 
 
 4469        .arg(inform->getLabel())
 
 4470        .arg(inform->getName())
 
 4471        .arg(inform->getClasses().toText());
 
 4488    if (ack->getRemoteAddr() != inform->getGiaddr()) {
 
 4490            .arg(inform->getLabel())
 
 4491            .arg(ack->getRemoteAddr())
 
 4492            .arg(ack->getIface());
 
 
 4506    if (query->getCiaddr().isV4Zero() || !query->getGiaddr().isV4Zero()) {
 
 4523    if (query->inClass(
"STASH_AGENT_OPTIONS")) {
 
 4527    if (!lease || lease->expired()) {
 
 4531    if (!user_context || (user_context->getType() != 
Element::map)) {
 
 4539    if (!relay_agent_info) {
 
 4544        relay_agent_info = relay_agent_info->get(
"sub-options");
 
 4545        if (!relay_agent_info) {
 
 4556        client_id.reset(
new ClientId(opt_clientid->getData()));
 
 4558    if (!lease->belongsToClient(query->getHWAddr(), client_id)) {
 
 4562    string rai_hex = relay_agent_info->stringValue();
 
 4563    if (rai_hex.empty()) {
 
 4566    vector<uint8_t> rai_data;
 
 4571    if (!rai || rai->getOptions().empty()) {
 
 4578    query->addOption(rai);
 
 4579    query->addClass(
"STASH_AGENT_OPTIONS");
 
 4582      .arg(query->getLabel())
 
 4583      .arg(query->getCiaddr())
 
 4584      .arg(rai->toText());
 
 
 4598            .arg(query->getLabel())
 
 4599            .arg(query->getIface());
 
 4607            .arg(query->getLabel())
 
 4608            .arg(query->getIface());
 
 
 4618    if (pkt->isRelayed()) {
 
 4623    if (pkt->isDhcp4o6()) {
 
 4632            if (pkt->getRemoteAddr().isV4Zero() &&
 
 4633                pkt->getCiaddr().isV4Zero()) {
 
 4644    bool result = (!pkt->getLocalAddr().isV4Bcast() ||
 
 
 4659        type = query->getType();
 
 4663            .arg(query->getLabel())
 
 4664            .arg(query->getIface());
 
 4688                     .arg(query->getLabel());
 
 4695                          .arg(query->getLabel())
 
 4700                      .arg(query->getLabel())
 
 
 4727        boost::dynamic_pointer_cast<OptionCustom>(option);
 
 4730    if (!option_custom) {
 
 4738    if (option_custom->getDataFieldsNum() != 1) {
 
 4744    IOAddress server_id = option_custom->readAddress();
 
 4745    if (!server_id.
isV4()) {
 
 4754        if (rai_suboption && (server_id.
toBytes() == rai_suboption->toBinary())) {
 
 4761    if (cfg->getIgnoreServerIdentifier()) {
 
 4799    if (cfg_subnets->hasSubnetWithServerId(server_id)) {
 
 4806    if (cfg_networks->hasNetworkWithServerId(server_id)) {
 
 4812    for (
auto const& cclass : classes) {
 
 4815            getClientClassDictionary()->findClass(cclass);
 
 4820        if (ccdef->getCfgOption()->empty()) {
 
 4825        OptionCustomPtr context_opt_server_id = boost::dynamic_pointer_cast<OptionCustom>
 
 4827        if (context_opt_server_id && (context_opt_server_id->readAddress() == server_id)) {
 
 4835    OptionCustomPtr opt_server_id = boost::dynamic_pointer_cast<OptionCustom>
 
 4838    return (opt_server_id && (opt_server_id->readAddress() == server_id));
 
 
 4843    switch (query->getType()) {
 
 
 4878                      << 
" received in message " 
 4879                      << query->getName());
 
 4886                      " received in message " 
 4887                      << query->getName());
 
 4897    if (query->getHWAddr() && !query->getHWAddr()->hwaddr_.empty()) {
 
 4906    if (!client_id || client_id->len() == client_id->getHeaderLen()) {
 
 4908                  " provided in message " 
 4909                  << query->getName());
 
 
 4930            addr = resp->getYiaddr();
 
 4935                const ClientClasses& pool_to_add = pool->getAdditionalClasses();
 
 4936                for (
auto const& cclass : pool_to_add) {
 
 4943        const ClientClasses& to_add = subnet->getAdditionalClasses();
 
 4944        for (
auto const& cclass : to_add) {
 
 4950        subnet->getSharedNetwork(network);
 
 4952            const ClientClasses& net_to_add = network->getAdditionalClasses();
 
 4953            for (
auto const& cclass : net_to_add) {
 
 4963    for (
auto const& cclass : classes) {
 
 4978            query->addClass(cclass);
 
 4986                .arg(query->getLabel())
 
 4988                .arg(status ? 
"true" : 
"false");
 
 4991                query->addClass(cclass);
 
 4995                .arg(query->getLabel())
 
 
 5005    for (
auto const& code : query->getDeferredOptions()) {
 
 5009        for (
auto const& cclass : classes) {
 
 5013                getClientClassDictionary()->findClass(cclass);
 
 5019            if (!ccdef->getCfgOptionDef()) {
 
 5049                .arg(query->getLabel())
 
 5058            opt = def->optionFactory(
Option::V4, code, buf);
 
 5059        } 
catch (
const std::exception& e) {
 
 5063                .arg(query->getLabel())
 
 5068        while (query->delOption(code)) {
 
 5072        query->addOption(opt);
 
 
 5084                                     this, ph::_1, ph::_2));
 
 
 5103              arg(result).arg((ncr ? ncr->toText() : 
" NULL "));
 
 
 5112    std::stringstream tmp;
 
 5116        tmp << 
" (" << EXTENDED_VERSION << 
")" << endl;
 
 5117        tmp << 
"premium: " << PREMIUM_EXTENDED_VERSION << endl;
 
 5118        tmp << 
"linked with:" << endl;
 
 5123            tmp << endl << 
"lease backends:";
 
 5125                tmp << endl << 
"- " << 
version;
 
 5130            tmp << endl << 
"host backends:";
 
 5132                tmp << endl << 
"- " << 
version;
 
 5137            tmp << endl << 
"forensic backends:";
 
 5139                tmp << endl << 
"- " << 
version;
 
 
 5152    string stat_name = 
"pkt4-unknown-received";
 
 5154        switch (query->getType()) {
 
 5156            stat_name = 
"pkt4-discover-received";
 
 5160            stat_name = 
"pkt4-offer-received";
 
 5163            stat_name = 
"pkt4-request-received";
 
 5167            stat_name = 
"pkt4-ack-received";
 
 5171            stat_name = 
"pkt4-nak-received";
 
 5174            stat_name = 
"pkt4-release-received";
 
 5177            stat_name = 
"pkt4-decline-received";
 
 5180            stat_name = 
"pkt4-inform-received";
 
 5194                                              static_cast<int64_t
>(1));
 
 
 5200                                              static_cast<int64_t
>(1));
 
 5204    switch (response->getType()) {
 
 5206        stat_name = 
"pkt4-offer-sent";
 
 5209        stat_name = 
"pkt4-ack-sent";
 
 5212        stat_name = 
"pkt4-nak-sent";
 
 5220                                              static_cast<int64_t
>(1));
 
 
 5224    return (
Hooks.hook_index_buffer4_receive_);
 
 
 5228    return (
Hooks.hook_index_pkt4_receive_);
 
 
 5232    return (
Hooks.hook_index_subnet4_select_);
 
 
 5236    return (
Hooks.hook_index_lease4_release_);
 
 
 5240    return (
Hooks.hook_index_pkt4_send_);
 
 
 5244    return (
Hooks.hook_index_buffer4_send_);
 
 
 5248    return (
Hooks.hook_index_lease4_decline_);
 
 
 5258    char const* 
const rotate(getenv(
"KEA_DHCP4_FUZZING_ROTATE_PORT"));
 
 5262        while (!locker.
lock()) {
 
 5263            this_thread::sleep_for(1s);
 
 5266        port_file.open(
"/tmp/port4.txt", ios::in);
 
 5269        getline(port_file, line);
 
 5281        port_file.open(
"/tmp/port4.txt", ios::out | ios::trunc);
 
 5282        port_file << to_string(port) << endl;
 
 
 5292    static std::list<std::list<std::string>> 
const list({
 
 5293        {
"config-control", 
"config-databases", 
"[]"},
 
 5294        {
"hooks-libraries", 
"[]", 
"parameters", 
"*"},
 
 5296        {
"hosts-databases", 
"[]"},
 
 
Defines elements for storing the names of client classes.
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 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.
static const IOAddress & IPV4_BCAST_ADDRESS()
Returns a "255.255.255.255" broadcast address.
uint32_t toUint32() const
Converts IPv4 address to uint32_t.
bool isV4() const
Convenience function to check for an IPv4 address.
std::vector< uint8_t > toBytes() const
Return address as set of bytes.
bool isV4Bcast() const
Convenience function to check if it is an IPv4 broadcast address.
void clearIOServices()
Clear the list of IOService objects.
static IOServiceMgr & instance()
Access the IOServiceMgr singleton instance.
void pollIOServices()
Poll IOService objects.
The IOService class is a wrapper for the ASIO io_context class.
static std::string getVersion()
Get version string.
DHCPv4 and DHCPv6 allocation engine.
boost::shared_ptr< ClientContext4 > ClientContext4Ptr
Pointer to the ClientContext4.
static uint32_t getValidLft(const ClientContext4 &ctx)
Returns the valid lifetime based on the v4 context.
Implementation of the mechanisms to control the use of the Configuration Backends by the DHCPv4 serve...
@ EARLY_GLOBAL_RESERVATIONS_LOOKUP
@ USE_ROUTING
Server uses routing to determine the right interface to send response.
@ SOCKET_UDP
Datagram socket, i.e. IP/UDP socket.
D2ClientMgr & getD2ClientMgr()
Fetches the DHCP-DDNS manager.
static CfgMgr & instance()
returns a single instance of Configuration Manager
SrvConfigPtr getCurrentCfg()
Returns a pointer to the current configuration.
static SubnetSelector initSelector(const Pkt4Ptr &query)
Build selector from a client's message.
Container for storing client class names.
void insert(const ClientClass &class_name)
Insert an element.
bool empty() const
Check if classes is empty.
std::string toText(const std::string &separator=", ") const
Returns all class names as text.
Client race avoidance RAII handler.
bool tryLock(Pkt4Ptr query, ContinuationPtr cont=ContinuationPtr())
Tries to acquires a client.
Holds Client identifier or client IPv4 address.
ReplaceClientNameMode
Defines the client name replacement modes.
D2ClientMgr isolates Kea from the details of being a D2 client.
std::string generateFqdn(const asiolink::IOAddress &address, const DdnsParams &ddns_params, const bool trailing_dot=true) const
Builds a FQDN based on the configuration and given IP address.
bool ddnsEnabled()
Convenience method for checking if DHCP-DDNS is enabled.
void getUpdateDirections(const T &fqdn_resp, bool &forward, bool &reverse)
Get directional update flags based on server FQDN flags.
void stop()
Stop the sender.
void suspendUpdates()
Suspends sending requests.
void adjustDomainName(const T &fqdn, T &fqdn_resp, const DdnsParams &ddns_params)
Set server FQDN name based on configuration and a given FQDN.
void stopSender()
Disables sending NameChangeRequests to kea-dhcp-ddns.
void adjustFqdnFlags(const T &fqdn, T &fqdn_resp, const DdnsParams &ddns_params)
Set server FQDN flags based on configuration and a given FQDN.
std::string qualifyName(const std::string &partial_name, const DdnsParams &ddns_params, const bool trailing_dot) const
Adds a qualifying suffix to a given domain name.
void startSender(D2ClientErrorHandler error_handler, const isc::asiolink::IOServicePtr &io_service)
Enables sending NameChangeRequests to kea-dhcp-ddns.
Convenience container for conveying DDNS behavioral parameters It is intended to be created per Packe...
bool getUpdateOnRenew() const
Returns whether or not DNS should be updated when leases renew.
bool getEnableUpdates() const
Returns whether or not DHCP DDNS updating is enabled.
void close()
Close communication socket.
static Dhcp4to6Ipc & instance()
Returns pointer to the sole instance of Dhcp4to6Ipc.
AllocEngine::ClientContext4Ptr getContext() const
Returns the copy of the context for the Allocation engine.
void deleteResponse()
Removes the response message by resetting the pointer to null.
Pkt4Ptr getQuery() const
Returns the pointer to the query from the client.
static void setHostIdentifiers(AllocEngine::ClientContext4Ptr context)
Set host identifiers within a context.
static void classifyByVendor(const Pkt4Ptr &pkt)
Assign class using vendor-class-identifier option.
void initResponse()
Initializes the instance of the response message.
void setReservedMessageFields()
Sets reserved values of siaddr, sname and file in the server's response.
CfgOptionList & getCfgOptionList()
Returns the configured option list (non-const version)
Pkt4Ptr getResponse() const
Returns the pointer to the server's response.
static void setReservedClientClasses(AllocEngine::ClientContext4Ptr context)
Assigns classes retrieved from host reservation database.
void initResponse4o6()
Initializes the DHCPv6 part of the response message.
static void evaluateClasses(const Pkt4Ptr &pkt, bool depend_on_known)
Evaluate classes.
void setIPv6OnlyPreferred(bool ipv6_only_preferred)
Set the IPv6-Only Preferred flag.
Dhcpv4Exchange(const AllocEnginePtr &alloc_engine, const Pkt4Ptr &query, AllocEngine::ClientContext4Ptr &context, const ConstSubnet4Ptr &subnet, bool &drop)
Constructor.
static void classifyPacket(const Pkt4Ptr &pkt)
Assigns incoming packet to zero or more classes.
static void removeDependentEvaluatedClasses(const Pkt4Ptr &query)
Removed evaluated client classes.
bool getIPv6OnlyPreferred() const
Returns the IPv6-Only Preferred flag.
void conditionallySetReservedClientClasses()
Assigns classes retrieved from host reservation database if they haven't been yet set.
void initContext0(const Pkt4Ptr &query, AllocEngine::ClientContext4Ptr ctx)
Initialize client context (first part).
int run()
Main server processing loop.
void declineLease(const Lease4Ptr &lease, const Pkt4Ptr &decline, AllocEngine::ClientContext4Ptr &context)
Marks lease as declined.
void processPacketAndSendResponse(Pkt4Ptr query)
Process a single incoming DHCPv4 packet and sends the response.
void classifyPacket(const Pkt4Ptr &pkt)
Assigns incoming packet to zero or more classes.
void appendRequestedVendorOptions(Dhcpv4Exchange &ex)
Appends requested vendor options as requested by client.
void adjustIfaceData(Dhcpv4Exchange &ex)
Set IP/UDP and interface parameters for the DHCPv4 response.
static uint16_t checkRelayPort(const Dhcpv4Exchange &ex)
Check if the relay port RAI sub-option was set in the query.
virtual ~Dhcpv4Srv()
Destructor. Used during DHCPv4 service shutdown.
virtual Pkt4Ptr receivePacket(int timeout)
dummy wrapper around IfaceMgr::receive4
isc::dhcp::ConstSubnet4Ptr selectSubnet4o6(const Pkt4Ptr &query, bool &drop, bool sanity_only=false, bool allow_answer_park=true)
Selects a subnet for a given client's DHCP4o6 packet.
bool accept(const Pkt4Ptr &query)
Checks whether received message should be processed or discarded.
void setTeeTimes(const Lease4Ptr &lease, const ConstSubnet4Ptr &subnet, Pkt4Ptr resp)
Adds the T1 and T2 timers to the outbound response as appropriate.
static void appendServerID(Dhcpv4Exchange &ex)
Adds server identifier option to the server's response.
void postAllocateNameUpdate(const AllocEngine::ClientContext4Ptr &ctx, const Lease4Ptr &lease, const Pkt4Ptr &query, const Pkt4Ptr &resp, bool client_name_changed)
Update client name and DNS flags in the lease and response.
bool use_bcast_
Should broadcast be enabled on sockets (if true).
void runOne()
Main server processing step.
void startD2()
Starts DHCP_DDNS client IO if DDNS updates are enabled.
static int getHookIndexBuffer4Receive()
Returns the index for "buffer4_receive" hook point.
Pkt4Ptr processRequest(Pkt4Ptr &request, AllocEngine::ClientContext4Ptr &context)
Processes incoming REQUEST and returns REPLY response.
static void processStatsReceived(const Pkt4Ptr &query)
Class methods for DHCPv4-over-DHCPv6 handler.
static int getHookIndexPkt4Send()
Returns the index for "pkt4_send" hook point.
void processDecline(Pkt4Ptr &decline, AllocEngine::ClientContext4Ptr &context)
Process incoming DHCPDECLINE messages.
Dhcpv4Srv(uint16_t server_port=DHCP4_SERVER_PORT, uint16_t client_port=0, const bool use_bcast=true, const bool direct_response_desired=true)
Default constructor.
isc::dhcp::ConstSubnet4Ptr selectSubnet(const Pkt4Ptr &query, bool &drop, bool sanity_only=false, bool allow_answer_park=true)
Selects a subnet for a given client's packet.
static int getHookIndexSubnet4Select()
Returns the index for "subnet4_select" hook point.
static void processStatsSent(const Pkt4Ptr &response)
Updates statistics for transmitted packets.
void shutdown() override
Instructs the server to shut down.
static int getHookIndexLease4Release()
Returns the index for "lease4_release" hook point.
void adjustRemoteAddr(Dhcpv4Exchange &ex)
Sets remote addresses for outgoing packet.
static int getHookIndexPkt4Receive()
Returns the index for "pkt4_receive" hook point.
void assignLease(Dhcpv4Exchange &ex)
Assigns a lease and appends corresponding options.
void evaluateAdditionalClasses(Dhcpv4Exchange &ex)
Evaluates classes in the additional classes lists.
Pkt4Ptr processDhcp4Query(Pkt4Ptr query, bool allow_answer_park)
Process a single incoming DHCPv4 query.
asiolink::IOServicePtr & getIOService()
Returns pointer to the IO service used by the server.
void setFixedFields(Dhcpv4Exchange &ex)
Sets fixed fields of the outgoing packet.
void appendBasicOptions(Dhcpv4Exchange &ex)
Append basic options if they are not present.
void recoverStashedAgentOption(const Pkt4Ptr &query)
Recover stashed agent options from client address lease.
void processClientName(Dhcpv4Exchange &ex)
Processes Client FQDN and Hostname Options sent by a client.
boost::shared_ptr< AllocEngine > alloc_engine_
Allocation Engine.
void serverDecline(hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &query, Lease4Ptr lease, bool lease_exists)
Renders a lease declined after the server has detected, via ping-check or other means,...
Pkt4Ptr processInform(Pkt4Ptr &inform, AllocEngine::ClientContext4Ptr &context)
Processes incoming DHCPINFORM messages.
uint16_t client_port_
UDP port number to which server sends all responses.
void serverDeclineNoThrow(hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &query, Lease4Ptr lease, bool lease_exists)
Exception safe wrapper around serverDecline()
void processPacketPktSend(hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &query, Pkt4Ptr &rsp, ConstSubnet4Ptr &subnet)
Executes pkt4_send callout.
void processPacketAndSendResponseNoThrow(Pkt4Ptr query)
Process a single incoming DHCPv4 packet and sends the response.
std::list< std::list< std::string > > jsonPathsToRedact() const final override
Return a list of all paths that contain passwords or secrets for kea-dhcp4.
static std::string srvidToString(const OptionPtr &opt)
converts server-id to text Converts content of server-id option to a text representation,...
bool acceptServerId(const Pkt4Ptr &pkt) const
Verifies if the server id belongs to our server.
static const std::string VENDOR_CLASS_PREFIX
this is a prefix added to the content of vendor-class option
void createNameChangeRequests(const Lease4Ptr &lease, const Lease4Ptr &old_lease, const DdnsParams &ddns_params)
Creates NameChangeRequests which correspond to the lease which has been acquired.
void appendRequestedOptions(Dhcpv4Exchange &ex)
Appends options requested by client.
void setPacketStatisticsDefaults()
This function sets statistics related to DHCPv4 packets processing to their initial values.
void processLocalizedQuery4AndSendResponse(Pkt4Ptr query, AllocEngine::ClientContext4Ptr &ctx, bool allow_answer_park)
Process a localized incoming DHCPv4 query.
static std::string getVersion(bool extended)
returns Kea version on stdout and exit.
void buildCfgOptionList(Dhcpv4Exchange &ex)
Build the configured option list.
volatile bool shutdown_
Indicates if shutdown is in progress.
uint16_t server_port_
UDP port number on which server listens.
void sendResponseNoThrow(hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &query, Pkt4Ptr &rsp, ConstSubnet4Ptr &subnet)
Process an unparked DHCPv4 packet and sends the response.
bool earlyGHRLookup(const Pkt4Ptr &query, AllocEngine::ClientContext4Ptr ctx)
Initialize client context and perform early global reservations lookup.
NetworkStatePtr network_state_
Holds information about disabled DHCP service and/or disabled subnet/network scopes.
void processDhcp4QueryAndSendResponse(Pkt4Ptr query, bool allow_answer_park)
Process a single incoming DHCPv4 query.
bool getSendResponsesToSource() const
Returns value of the test_send_responses_to_source_ flag.
Pkt4Ptr processDiscover(Pkt4Ptr &discover, AllocEngine::ClientContext4Ptr &context)
Processes incoming DISCOVER and returns response.
virtual void d2ClientErrorHandler(const dhcp_ddns::NameChangeSender::Result result, dhcp_ddns::NameChangeRequestPtr &ncr)
Implements the error handler for DHCP_DDNS IO errors.
uint16_t getServerPort() const
Get UDP port on which server should listen.
virtual void sendPacket(const Pkt4Ptr &pkt)
dummy wrapper around IfaceMgr::send()
static int getHookIndexBuffer4Send()
Returns the index for "buffer4_send" hook point.
void stopD2()
Stops DHCP_DDNS client IO if DDNS updates are enabled.
static void sanityCheck(const Pkt4Ptr &query)
Verifies if specified packet meets RFC requirements.
bool acceptMessageType(const Pkt4Ptr &query) const
Check if received message type is valid for the server to process.
void discardPackets()
Discards parked packets Clears the packet parking lots of all packets.
static int getHookIndexLease4Decline()
Returns the index for "lease4_decline" hook point.
void processRelease(Pkt4Ptr &release, AllocEngine::ClientContext4Ptr &context)
Processes incoming DHCPRELEASE messages.
bool acceptDirectRequest(const Pkt4Ptr &query)
Check if a message sent by directly connected client should be accepted or discarded.
CBControlDHCPv4Ptr cb_control_
Controls access to the configuration backends.
RequirementLevel
defines if certain option may, must or must not appear
Pkt4Ptr processPacket(Pkt4Ptr query, bool allow_answer_park=true)
Process a single incoming DHCPv4 packet.
void processPacketBufferSend(hooks::CalloutHandlePtr &callout_handle, Pkt4Ptr &rsp)
Executes buffer4_send callout and sends the response.
bool assignZero(ConstSubnet4Ptr &subnet, const ClientClasses &client_classes)
Assign the 0.0.0.0 address to an IPv6-Only client.
void deferredUnpack(Pkt4Ptr &query)
Perform deferred option unpacking.
Pkt4Ptr processLocalizedQuery4(AllocEngine::ClientContext4Ptr &ctx, bool allow_answer_park)
Process a localized incoming DHCPv4 query.
static std::list< std::string > getDBVersions()
Return extended version info for registered backends.
static void create()
Creates new instance of the HostMgr.
IdentifierType
Type of the host identifier.
@ IDENT_FLEX
Flexible host identifier.
std::string getIdentifierAsText() const
Returns host identifier in a textual form.
static IfaceMgr & instance()
IfaceMgr is a singleton class.
bool send(const Pkt6Ptr &pkt)
Sends an IPv6 packet.
void closeSockets()
Closes all open sockets.
void setMatchingPacketFilter(const bool direct_response_desired=false)
Set Packet Filter object to handle send/receive packets.
uint16_t getSocket(const isc::dhcp::Pkt6Ptr &pkt)
Return most suitable socket for transmitting specified IPv6 packet.
static TrackingLeaseMgr & instance()
Return current lease manager.
static std::list< std::string > getDBVersions()
Return extended version info for registered backends.
static void destroy()
Destroy lease manager.
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 bool deleteLease(const Lease4Ptr &lease)=0
Deletes an IPv4 lease.
virtual void updateLease4(const Lease4Ptr &lease4)=0
Updates IPv4 lease.
static std::list< std::string > getDBVersions()
Return extended version info for registered backends.
static OptionDefinitionPtr getOptionDef(const std::string &space, const uint16_t code)
Return the first option definition matching a particular option code.
static const OptionDefinition & DHO_DHCP_SERVER_IDENTIFIER_DEF()
Get definition of DHO_DHCP_SERVER_IDENTIFIER option.
static const OptionDefinition & DHO_DHCP_AGENT_OPTIONS_DEF()
Get definition of DHO_DHCP_AGENT_OPTIONS option.
static OptionDefinitionPtr getRuntimeOptionDef(const std::string &space, const uint16_t code)
Returns runtime (non-standard) option definition by space and option code.
static OptionDefinitionPtr getLastResortOptionDef(const std::string &space, const uint16_t code)
Returns last resort option definition by space and option code.
Controls the DHCP service enabling status.
Attempt to update lease that was not there.
std::vector< isc::asiolink::IOAddress > AddressContainer
Defines a collection of IPv4 addresses.
Represents DHCPv4 Client FQDN Option (code 81).
static const uint8_t FLAG_N
Bit N.
bool getFlag(const uint8_t flag) const
Checks if the specified flag of the DHCPv4 Client FQDN Option is set.
static const uint8_t FLAG_S
Bit S.
void setDomainName(const std::string &domain_name, const DomainNameType domain_name_type)
Set new domain-name.
void setFlag(const uint8_t flag, const bool set)
Modifies the value of the specified DHCPv4 Client Fqdn Option flag.
static const uint8_t FLAG_E
Bit E.
virtual std::string toText(int indent=0) const
Returns string representation of the option.
Option with defined data fields represented as buffers that can be accessed using data field index.
static unsigned int getLabelCount(const std::string &text_name)
Return the number of labels in the Name.
Base class representing a DHCP option definition.
OptionPtr option_
Option instance.
bool allowedForClientClasses(const ClientClasses &cclasses) const
Validates an OptionDescriptor's client-classes against a list of classes.
Forward declaration to OptionInt.
This class represents vendor-specific information option.
static const size_t OPTION4_HDR_LEN
length of the usual DHCPv4 option header (there are exceptions)
Represents DHCPv4 packet.
static const uint16_t FLAG_BROADCAST_MASK
Mask for the value of flags field in the DHCPv4 message to check whether client requested broadcast r...
Represents DHCPv4-over-DHCPv6 packet.
Represents a DHCPv6 packet.
An exception that is thrown if a DHCPv6 protocol violation occurs while processing a message (e....
Resource race avoidance RAII handler for DHCPv4.
bool tryLock4(const asiolink::IOAddress &addr)
Tries to acquires a resource.
RAII object enabling copying options retrieved from the packet.
Exception thrown when a call to select is interrupted by a signal.
Exception thrown during option unpacking This exception is thrown when an error has occurred,...
Result
Defines the outcome of an asynchronous NCR send.
@ NEXT_STEP_PARK
park the packet
@ NEXT_STEP_CONTINUE
continue normally
@ NEXT_STEP_DROP
drop the packet
@ NEXT_STEP_SKIP
skip the next processing step
static int registerHook(const std::string &name)
Register Hook.
static bool calloutsPresent(int index)
Are callouts present?
static std::vector< std::string > getLibraryNames()
Return list of loaded libraries.
static bool unloadLibraries()
Unload libraries.
static void park(const std::string &hook_name, T parked_object, std::function< void()> unpark_callback)
Park an object (packet).
static void callCallouts(int index, CalloutHandle &handle)
Calls the callouts for a given hook.
static void prepareUnloadLibraries()
Prepare the unloading of libraries.
static bool drop(const std::string &hook_name, T parked_object)
Removes parked object without calling a callback.
static void clearParkingLots()
Clears any parking packets.
Wrapper class around callout handle which automatically resets handle's state.
static ServerHooks & getServerHooks()
Return ServerHooks object.
static std::string getVersion()
Version.
File-based Interprocess Sync Class.
Interprocess Sync Locker Class.
bool unlock()
Release the lock.
bool lock()
Acquire the lock (blocks if something else has acquired a lock on the same task name)
int getExitValue()
Fetches the exit value.
Statistics Manager class.
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.
ThreadPool< std::function< void()> > & getThreadPool()
Get the dhcp thread pool.
void apply(bool enabled, uint32_t thread_count, uint32_t queue_size)
Apply the multi-threading related settings.
Defines classes for storing client class definitions.
int version()
returns Kea hooks version.
Defines the D2ClientConfig class.
Defines the D2ClientMgr class.
Contains declarations for loggers used by the DHCPv4 server component.
Defines the Dhcp4o6Ipc class.
#define VENDOR_ID_CABLE_LABS
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
boost::shared_ptr< OptionUint8Array > OptionUint8ArrayPtr
OptionIntArray< uint8_t > OptionUint8Array
OptionInt< uint32_t > OptionUint32
boost::shared_ptr< OptionUint32 > OptionUint32Ptr
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.
int get(CalloutHandle &handle)
The gss-tsig-get command.
When a message is logged with DEBUG severity, the debug level associated with the message is also spe...
#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.
IOAddress getNetmask4(uint8_t len)
Generates an IPv4 netmask of specified length.
boost::shared_ptr< const Element > ConstElementPtr
boost::shared_ptr< NameChangeRequest > NameChangeRequestPtr
Defines a pointer to a NameChangeRequest.
const isc::log::MessageID DHCP4_BUFFER_RECEIVE_FAIL
boost::shared_ptr< OptionVendor > OptionVendorPtr
Pointer to a vendor option.
isc::log::Logger ddns4_logger(DHCP4_DDNS_LOGGER_NAME)
Logger for Hostname or FQDN processing.
const isc::log::MessageID DHCP4_PACKET_DROP_0004
const isc::log::MessageID DHCP4_SRV_DHCP4O6_ERROR
const isc::log::MessageID DHCP4_RELEASE_EXCEPTION
const isc::log::MessageID DHCP4_SUBNET_DATA
const isc::log::MessageID DHCP4_INIT_REBOOT
const isc::log::MessageID DHCP4_HOOK_PACKET_SEND_SKIP
const isc::log::MessageID DHCP4_FLEX_ID
const isc::log::MessageID DHCP4_PACKET_DROP_0003
const isc::log::MessageID DHCP4_HOOK_SUBNET4_SELECT_PARKING_LOT_FULL
const isc::log::MessageID DHCP4_DEFERRED_OPTION_UNPACK_FAIL
const isc::log::MessageID DHCP4_PACKET_DROP_0001
const isc::log::MessageID DHCP4_QUERY_DATA
const isc::log::MessageID DHCP4_NO_LEASE_INIT_REBOOT
const isc::log::MessageID DHCP4_INFORM_DIRECT_REPLY
const isc::log::MessageID DHCP4_SERVER_INITIATED_DECLINE_ADD_FAILED
boost::shared_ptr< Lease4Collection > Lease4CollectionPtr
A shared pointer to the collection of IPv4 leases.
const isc::log::MessageID DHCP4_HOOK_LEASE4_OFFER_ARGUMENT_MISSING
void queueNCR(const NameChangeType &chg_type, const Lease4Ptr &lease)
Creates name change request from the DHCPv4 lease.
const isc::log::MessageID DHCP4_CLIENT_FQDN_PROCESS
const isc::log::MessageID DHCP4_DEFERRED_OPTION_MISSING
const isc::log::MessageID DHCP4_HOOK_SUBNET4_SELECT_DROP
@ DHO_DOMAIN_NAME_SERVERS
@ DHO_VENDOR_CLASS_IDENTIFIER
@ DHO_DHCP_REBINDING_TIME
@ DHO_DHCP_SERVER_IDENTIFIER
@ DHO_DHCP_CLIENT_IDENTIFIER
@ DHO_DHCP_REQUESTED_ADDRESS
@ DHO_DHCP_PARAMETER_REQUEST_LIST
const isc::log::MessageID DHCP4_PACKET_PROCESS_EXCEPTION_MAIN
const isc::log::MessageID DHCP4_PACKET_DROP_0008
const isc::log::MessageID DHCP4_RELEASE_EXPIRED
const isc::log::MessageID DHCP4_HOOK_LEASES4_COMMITTED_DROP
const isc::log::MessageID DHCP4_HOOK_SUBNET4_SELECT_4O6_PARKING_LOT_FULL
const isc::log::MessageID DHCP4_DHCP4O6_SUBNET_SELECTION_FAILED
const isc::log::MessageID DHCP4_RELEASE_FAIL_WRONG_CLIENT
const isc::log::MessageID DHCP4_HOOK_LEASES4_COMMITTED_PARKING_LOT_FULL
const isc::log::MessageID DHCP4_HOOK_BUFFER_RCVD_DROP
boost::shared_ptr< const Subnet4 > ConstSubnet4Ptr
A const pointer to a Subnet4 object.
boost::shared_ptr< OptionCustom > OptionCustomPtr
A pointer to the OptionCustom object.
const isc::log::MessageID DHCP4_HOOK_PACKET_RCVD_SKIP
const int DBG_DHCP4_BASIC_DATA
Debug level used to log the traces with some basic data.
const isc::log::MessageID DHCP4_LEASE_ALLOC
const int DBG_DHCP4_DETAIL
Debug level used to trace detailed errors.
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
isc::log::Logger lease4_logger(DHCP4_LEASE_LOGGER_NAME)
Logger for lease allocation logic.
const isc::log::MessageID DHCP4_NCR_CREATION_FAILED
isc::log::Logger options4_logger(DHCP4_OPTIONS_LOGGER_NAME)
Logger for options parser.
const isc::log::MessageID DHCP4_HOOK_SUBNET4_SELECT_SKIP
const int DBG_DHCP4_DETAIL_DATA
This level is used to log the contents of packets received and sent.
const isc::log::MessageID DHCP4_PACKET_PACK
boost::shared_ptr< AllocEngine > AllocEnginePtr
A pointer to the AllocEngine object.
ContinuationPtr makeContinuation(Continuation &&cont)
Continuation factory.
const isc::log::MessageID DHCP4_DECLINE_FAIL
const isc::log::MessageID DHCP4_RECOVERED_STASHED_RELAY_AGENT_INFO
const isc::log::MessageID DHCP4_LEASE_REUSE
const isc::log::MessageID DHCP4_HOOK_SUBNET4_SELECT_PARK
boost::shared_ptr< const CfgHostOperations > ConstCfgHostOperationsPtr
Pointer to the const object.
boost::shared_ptr< CfgIface > CfgIfacePtr
A pointer to the CfgIface .
const isc::log::MessageID DHCP4_PACKET_PACK_FAIL
boost::shared_ptr< ClientClassDef > ClientClassDefPtr
a pointer to an ClientClassDef
const isc::log::MessageID DHCP4_DDNS_REQUEST_SEND_FAILED
const isc::log::MessageID DHCP4_GENERATE_FQDN
const isc::log::MessageID DHCP4_CLASS_ASSIGNED
const isc::log::MessageID DHCP4_PACKET_PROCESS_STD_EXCEPTION
boost::shared_ptr< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
const isc::log::MessageID DHCP4_RESPONSE_HOSTNAME_DATA
const isc::log::MessageID DHCP4_BUFFER_WAIT_SIGNAL
const isc::log::MessageID DHCP4_HOOK_LEASE4_RELEASE_SKIP
const isc::log::MessageID DHCP4_POST_ALLOCATION_NAME_UPDATE_FAIL
const isc::log::MessageID DHCP4_PACKET_NAK_0001
const isc::log::MessageID DHCP4_HOOK_DECLINE_SKIP
const isc::log::MessageID DHCP4_HOOK_LEASE4_OFFER_PARK
const isc::log::MessageID DHCP4_DECLINE_LEASE_MISMATCH
const isc::log::MessageID DHCP4_SRV_UNLOAD_LIBRARIES_ERROR
const isc::log::MessageID DHCP4_ADDITIONAL_CLASS_EVAL_ERROR
const isc::log::MessageID DHCP4_RESPONSE_HOSTNAME_GENERATE
boost::shared_ptr< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
const isc::log::MessageID DHCP4_PACKET_DROP_0013
const isc::log::MessageID DHCP4_PACKET_QUEUE_FULL
const isc::log::MessageID DHCP4_LEASE_OFFER
const isc::log::MessageID DHCP4_PACKET_DROP_0009
const isc::log::MessageID DHCP4_PACKET_RECEIVED
boost::shared_ptr< Pkt4o6 > Pkt4o6Ptr
A pointer to Pkt4o6 object.
const isc::log::MessageID DHCP4_RELEASE_DELETED
const isc::log::MessageID DHCP4_BUFFER_UNPACK
const isc::log::MessageID DHCP4_CLIENT_HOSTNAME_DATA
OptionContainer::nth_index< 5 >::type OptionContainerCancelIndex
Type of the index #5 - option cancellation flag.
const isc::log::MessageID DHCP4_CLASSES_ASSIGNED_AFTER_SUBNET_SELECTION
const isc::log::MessageID DHCP4_PACKET_SEND_FAIL
std::pair< OptionContainerPersistIndex::const_iterator, OptionContainerPersistIndex::const_iterator > OptionContainerPersistRange
Pair of iterators to represent the range of options having the same persistency flag.
boost::shared_ptr< OptionDefinition > OptionDefinitionPtr
Pointer to option definition object.
const isc::log::MessageID DHCP4_DHCP4O6_SUBNET_DATA
boost::shared_ptr< Option4ClientFqdn > Option4ClientFqdnPtr
A pointer to the Option4ClientFqdn object.
const isc::log::MessageID DHCP4_CLIENTID_IGNORED_FOR_LEASES
const isc::log::MessageID DHCP4_CLIENT_NAME_PROC_FAIL
const isc::log::MessageID DHCP4_CLIENT_HOSTNAME_PROCESS
const isc::log::MessageID DHCP4_HOOK_DDNS_UPDATE
const isc::log::MessageID DHCP4_SRV_CONSTRUCT_ERROR
const isc::log::MessageID DHCP4_SERVER_INITIATED_DECLINE
boost::shared_ptr< Expression > ExpressionPtr
const isc::log::MessageID DHCP4_RELEASE_FAIL
const isc::log::MessageID DHCP4_RELEASE_FAIL_NO_LEASE
const isc::log::MessageID DHCP4_CLIENT_HOSTNAME_MALFORMED
boost::shared_ptr< Pool > PoolPtr
a pointer to either IPv4 or IPv6 Pool
boost::shared_ptr< OptionString > OptionStringPtr
Pointer to the OptionString object.
isc::log::Logger bad_packet4_logger(DHCP4_BAD_PACKET_LOGGER_NAME)
Logger for rejected packets.
isc::hooks::CalloutHandlePtr getCalloutHandle(const T &pktptr)
CalloutHandle Store.
const isc::log::MessageID DHCP4_V6_ONLY_PREFERRED_MISSING_IN_ACK
const isc::log::MessageID DHCP4_PACKET_DROP_0006
const int DBG_DHCP4_BASIC
Debug level used to trace basic operations within the code.
boost::shared_ptr< ClientClassDictionary > ClientClassDictionaryPtr
Defines a pointer to a ClientClassDictionary.
const isc::log::MessageID DHCP4_SRV_D2STOP_ERROR
const isc::log::MessageID DHCP4_SERVER_INITIATED_DECLINE_UPDATE_FAILED
const isc::log::MessageID DHCP4_RESPONSE_FQDN_DATA
boost::shared_ptr< ClientId > ClientIdPtr
Shared pointer to a Client ID.
boost::shared_ptr< Continuation > ContinuationPtr
Define the type of shared pointers to continuations.
const isc::log::MessageID DHCP4_DECLINE_LEASE_NOT_FOUND
boost::shared_ptr< OptionContainer > OptionContainerPtr
Pointer to the OptionContainer object.
boost::shared_ptr< ClientClassDefList > ClientClassDefListPtr
Defines a pointer to a ClientClassDefList.
const isc::log::MessageID DHCP4_PACKET_DROP_0005
const isc::log::MessageID DHCP4_SUBNET_DYNAMICALLY_CHANGED
const isc::log::MessageID DHCP4_SHUTDOWN_REQUEST
@ DHCP_NOTYPE
Message Type option missing.
const isc::log::MessageID DHCP4_PACKET_NAK_0003
const isc::log::MessageID DHCP4_TESTING_MODE_SEND_TO_SOURCE_ENABLED
boost::shared_ptr< const CfgSubnets4 > ConstCfgSubnets4Ptr
Const pointer.
const isc::log::MessageID DHCP4_BUFFER_RECEIVED
bool evaluateBool(const Expression &expr, Pkt &pkt)
Evaluate a RPN expression for a v4 or v6 packet and return a true or false decision.
const isc::log::MessageID DHCP4_SUBNET_SELECTION_FAILED
boost::shared_ptr< const Host > ConstHostPtr
Const pointer to the Host object.
const isc::log::MessageID DHCP4_RESPONSE_DATA
const isc::log::MessageID DHCP4_ADDITIONAL_CLASS_NO_TEST
isc::log::Logger packet4_logger(DHCP4_PACKET_LOGGER_NAME)
Logger for processed packets.
OptionContainer::nth_index< 2 >::type OptionContainerPersistIndex
Type of the index #2 - option persistency flag.
const isc::log::MessageID DHCP4_DECLINE_LEASE
const isc::log::MessageID DHCP4_PACKET_SEND
boost::shared_ptr< OptionVendorClass > OptionVendorClassPtr
Defines a pointer to the OptionVendorClass.
const isc::log::MessageID DHCP4_RELEASE
const isc::log::MessageID DHCP4_HOOK_LEASE4_OFFER_DROP
const isc::log::MessageID DHCP4_HOOK_BUFFER_RCVD_SKIP
const isc::log::MessageID DHCP4_UNKNOWN_ADDRESS_REQUESTED
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
const isc::log::MessageID DHCP4_PACKET_PROCESS_STD_EXCEPTION_MAIN
const isc::log::MessageID DHCP4_DHCP4O6_HOOK_SUBNET4_SELECT_DROP
std::vector< uint8_t > OptionBuffer
buffer types used in DHCP code.
const isc::log::MessageID DHCP4_OPEN_SOCKET
const isc::log::MessageID DHCP4_PACKET_DROP_0007
boost::shared_ptr< CfgSharedNetworks4 > CfgSharedNetworks4Ptr
Pointer to the configuration of IPv4 shared networks.
const isc::log::MessageID DHCP4_HOOK_PACKET_SEND_DROP
const isc::log::MessageID DHCP4_RESERVED_HOSTNAME_ASSIGNED
isc::log::Logger dhcp4_logger(DHCP4_APP_LOGGER_NAME)
Base logger for DHCPv4 server.
const isc::log::MessageID DHCP4_CLASSES_ASSIGNED
@ RAI_OPTION_SERVER_ID_OVERRIDE
@ RAI_OPTION_AGENT_CIRCUIT_ID
const isc::log::MessageID DHCP4_QUERY_LABEL
bool isClientClassBuiltIn(const ClientClass &client_class)
Check if a client class name is builtin.
const isc::log::MessageID DHCP4_PACKET_NAK_0002
const int DBG_DHCP4_HOOKS
Debug level used to trace hook related operations.
boost::shared_ptr< SharedNetwork4 > SharedNetwork4Ptr
Pointer to SharedNetwork4 object.
std::vector< Lease4Ptr > Lease4Collection
A collection of IPv4 leases.
const isc::log::MessageID DHCP4_HOOK_BUFFER_SEND_SKIP
const isc::log::MessageID DHCP4_PACKET_PROCESS_EXCEPTION
const isc::log::MessageID DHCP4_V6_ONLY_PREFERRED_MISSING_IN_OFFER
std::pair< OptionContainerCancelIndex::const_iterator, OptionContainerCancelIndex::const_iterator > OptionContainerCancelRange
Pair of iterators to represent the range of options having the same cancellation flag.
const isc::log::MessageID DHCP4_PACKET_OPTIONS_SKIPPED
const isc::log::MessageID DHCP4_EMPTY_HOSTNAME
const isc::log::MessageID DHCP4_REQUEST
const isc::log::MessageID DHCP4_SUBNET_SELECTED
const isc::log::MessageID DHCP4_PACKET_DROP_0010
boost::shared_ptr< Lease4 > Lease4Ptr
Pointer to a Lease4 structure.
const isc::log::MessageID DHCP4_SERVER_INITIATED_DECLINE_RESOURCE_BUSY
const isc::log::MessageID DHCP4_CLASS_UNCONFIGURED
const isc::log::MessageID DHCP4_DHCP4O6_SUBNET_SELECTED
boost::shared_ptr< Option > OptionPtr
const isc::log::MessageID DHCP4_HOOK_LEASE4_OFFER_PARKING_LOT_FULL
const int DBG_DHCP4_START
Debug level used to log information during server startup.
const isc::log::MessageID DHCP4_HOOK_LEASES4_COMMITTED_PARK
const isc::log::MessageID DHCP4_ADDITIONAL_CLASS_UNDEFINED
const isc::log::MessageID DHCP4_ADDITIONAL_CLASS_EVAL_RESULT
const isc::log::MessageID DHCP4_DHCP4O6_HOOK_SUBNET4_SELECT_SKIP
const isc::log::MessageID DHCP4_PACKET_DROP_0014
std::list< ConstCfgOptionPtr > CfgOptionList
Const pointer list.
const isc::log::MessageID DHCP4_DISCOVER
boost::shared_ptr< const CfgOption > ConstCfgOptionPtr
Const pointer.
const isc::log::MessageID DHCP4_PACKET_NAK_0004
const isc::log::MessageID DHCP4_CLIENT_FQDN_DATA
const isc::log::MessageID DHCP4_PACKET_DROP_0002
isc::log::Logger hooks_logger("hooks")
Hooks Logger.
boost::shared_ptr< CalloutHandle > CalloutHandlePtr
A shared pointer to a CalloutHandle object.
boost::shared_ptr< ParkingLot > ParkingLotPtr
Type of the pointer to the parking lot.
const int DBGLVL_TRACE_BASIC
Trace basic operations.
const int DBGLVL_PKT_HANDLING
This debug level is reserved for logging the details of packet handling, such as dropping the packet ...
std::unique_ptr< StringSanitizer > StringSanitizerPtr
Type representing the pointer to the StringSanitizer.
void decodeFormattedHexString(const string &hex_string, vector< uint8_t > &binary)
Converts a formatted string of hexadecimal digits into a vector.
string trim(const string &input)
Trim leading and trailing spaces.
Defines the logger used by the top-level component of kea-lfc.
This file defines abstract classes for exchanging NameChangeRequests.
This file provides the classes needed to embody, compose, and decompose DNS update requests that are ...
Standard implementation of read-write mutexes with writer preference using C++11 mutex and condition ...
#define DHCP4_OPTION_SPACE
global std option spaces
Context information for the DHCPv4 lease allocation.
static const uint32_t INFINITY_LFT
Infinity (means static, i.e. never expire)
static std::string lifetimeToText(uint32_t lifetime)
Print lifetime.
static const uint32_t STATE_DEFAULT
A lease in the default state.
static const uint32_t STATE_RELEASED
Released lease held in the database for lease affinity.
Subnet selector used to specify parameters used to select a subnet.
asiolink::IOAddress local_address_
Address on which the message was received.
bool dhcp4o6_
Specifies if the packet is DHCP4o6.
asiolink::IOAddress option_select_
RAI link select or subnet select option.
std::string iface_name_
Name of the interface on which the message was received.
asiolink::IOAddress ciaddr_
ciaddr from the client's message.
ClientClasses client_classes_
Classes that the client belongs to.
asiolink::IOAddress remote_address_
Source address of the message.
OptionPtr interface_id_
Interface id option.
asiolink::IOAddress first_relay_linkaddr_
First relay link address.
asiolink::IOAddress giaddr_
giaddr from the client's message.
bool add(const WorkItemPtr &item)
add a work item to the thread pool