lease6_callouts.cc

Go to the documentation of this file.

// Copyright (C) 2016-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#include <config.h>
#include <asiolink/asio_wrapper.h>
#include <cc/data.h>
#include <dhcp/dhcp6.h>
#include <dhcp/option_custom.h>
#include <dhcp/option6_ia.h>
#include <dhcp/option6_iaaddr.h>
#include <dhcp/option6_iaprefix.h>
#include <dhcp/pkt6.h>
#include <dhcpsrv/cfgmgr.h>
#include <dhcpsrv/cfg_subnets6.h>
#include <dhcpsrv/lease.h>
#include <eval/evaluate.h>
#include <hooks/hooks.h>
#include <util/str.h>
#include <legal_log_log.h>
#include <dhcpsrv/legal_log_mgr_factory.h>
#include <subnets_user_context.h>
 
#include <sstream>
 
using namespace isc;
using namespace isc::data;
using namespace isc::dhcp;
using namespace isc::util;
using namespace isc::util::str;
using namespace hooks;
using namespace legal_log;
using namespace std;

std::string hwaddrSourceToString(uint32_t source) {
    if (source == HWAddr::HWADDR_SOURCE_RAW) {
        return ("Raw Socket");
    }
    if (source == HWAddr::HWADDR_SOURCE_DUID) {
        return ("DUID");
    }
    if (source == HWAddr::HWADDR_SOURCE_IPV6_LINK_LOCAL) {
        return ("IPv6 Link Local");
    }
    if (source == HWAddr::HWADDR_SOURCE_CLIENT_ADDR_RELAY_OPTION) {
        return ("Client Address Relay Option");
    }
    if (source == HWAddr::HWADDR_SOURCE_REMOTE_ID) {
        return ("Remote ID");
    }
    if (source == HWAddr::HWADDR_SOURCE_SUBSCRIBER_ID) {
        return ("Subscriber ID");
    }
    if (source == HWAddr::HWADDR_SOURCE_DOCSIS_CMTS) {
        return ("DOCSIS CMTS");
    }
    if (source == HWAddr::HWADDR_SOURCE_DOCSIS_MODEM) {
        return ("DOCSIS MODEM");
    }
 
    return ("UNKNOWN");
}

std::string genLease6Addr(const Lease6Ptr& lease) {
    std::stringstream stream;
 
    stream << lease->addr_;
    if (lease->type_ == Lease::TYPE_PD) {
        stream << "/" << static_cast<int>(lease->prefixlen_);
    }
 
    return (stream.str());
}
 
namespace isc {
namespace dhcp {

class TokenLeaseIA_NA : public virtual TokenOption {
public:
    TokenLeaseIA_NA(const Lease6Ptr& lease, const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_NA }, rep_type), lease_(lease) {
        if (lease->type_ != Lease::TYPE_NA) {
            isc_throw(EvalTypeError, "Can not create token using non IPv6 address type");
        }
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        Pkt6* pkt6 = dynamic_cast<Pkt6*>(&pkt);
        if (!pkt6) {
            return (OptionPtr());
        }
        for (auto const& it : pkt6->getOptions(D6O_IA_NA)) {
            auto const& ia = boost::dynamic_pointer_cast<Option6IA>(it.second);
            if (ia && ia->getIAID() == lease_->iaid_) {
                OptionCollection opts = ia->getOptions();
                for (auto const& opt_it : opts) {
                    if (opt_it.second->getType() != D6O_IAADDR) {
                        continue;
                    }
                    Option6IAAddrPtr iaaddr =
                            boost::dynamic_pointer_cast<Option6IAAddr>(opt_it.second);
                    if (!iaaddr) {
                        continue;
                    }
                    if (iaaddr->getAddress() == lease_->addr_) {
                        boost::shared_ptr<Option6IA> ia_na(new Option6IA(D6O_IA_NA, ia->getIAID()));
                        ia_na->addOption(iaaddr);
                        for (auto const& other_opt_it : opts) {
                            if (other_opt_it.second->getType() == D6O_IAADDR ||
                                other_opt_it.second->getType() == D6O_IAPREFIX) {
                                continue;
                            }
                            ia_na->addOption(other_opt_it.second);
                        }
                        return (ia_na);
                    }
                }
            }
        }
        return (OptionPtr());
    }
 
private:
    Lease6Ptr lease_;
};

class TokenFilterIA_NA : public virtual TokenOption {
public:
    TokenFilterIA_NA(const RepresentationType& rep_type) : TokenOption({ D6O_IA_NA }, rep_type) {
    }

    virtual OptionPtr getOption(Pkt&) {
        return (OptionPtr());
    }
};

class TokenLeaseIA_NASuboption : public virtual TokenLeaseIA_NA {
public:
    TokenLeaseIA_NASuboption(const Lease6Ptr& lease, const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_NA, D6O_IAADDR }, rep_type),
      TokenLeaseIA_NA(lease, rep_type) {
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        OptionPtr option = TokenLeaseIA_NA::getOption(pkt);
        if (option) {
            option = option->getOption(D6O_IAADDR);
        }
        return (option);
    }

    unsigned evaluate(Pkt& pkt, ValueStack& values) {
        return (TokenOption::evaluate(pkt, values));
    }
};

class TokenFilterIA_NASuboption : public virtual TokenFilterIA_NA {
public:
    TokenFilterIA_NASuboption(const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_NA, D6O_IAADDR }, rep_type),
      TokenFilterIA_NA(rep_type) {
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        return (TokenFilterIA_NA::getOption(pkt));
    }

    unsigned evaluate(Pkt& pkt, ValueStack& values) {
        return (TokenOption::evaluate(pkt, values));
    }
};

class TokenLeaseIA_PD : public virtual TokenOption {
public:
    TokenLeaseIA_PD(const Lease6Ptr& lease, const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_PD }, rep_type), lease_(lease) {
        if (lease->type_ != Lease::TYPE_PD) {
            isc_throw(EvalTypeError, "Can not create token using non IPv6 prefix type");
        }
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        Pkt6* pkt6 = dynamic_cast<Pkt6*>(&pkt);
        if (!pkt6) {
            return (OptionPtr());
        }
        for (auto const& it : pkt6->getOptions(D6O_IA_PD)) {
            auto const& ia = boost::dynamic_pointer_cast<Option6IA>(it.second);
            if (ia && ia->getIAID() == lease_->iaid_) {
                OptionCollection opts = ia->getOptions();
                for (auto const& opt_it : opts) {
                    if (opt_it.second->getType() != D6O_IAPREFIX) {
                        continue;
                    }
                    Option6IAPrefixPtr iaprefix =
                            boost::dynamic_pointer_cast<Option6IAPrefix>(opt_it.second);
                    if (!iaprefix) {
                        continue;
                    }
                    if ((iaprefix->getAddress() == lease_->addr_) &&
                        (iaprefix->getLength() == lease_->prefixlen_)) {
                        boost::shared_ptr<Option6IA> ia_pd(new Option6IA(D6O_IA_PD, ia->getIAID()));
                        ia_pd->addOption(iaprefix);
                        for (auto const& other_opt_it : opts) {
                            if (other_opt_it.second->getType() == D6O_IAADDR ||
                                other_opt_it.second->getType() == D6O_IAPREFIX) {
                                continue;
                            }
                            ia_pd->addOption(other_opt_it.second);
                        }
                        return (ia_pd);
                    }
                }
            }
        }
        return (OptionPtr());
    }
 
private:
    Lease6Ptr lease_;
};

class TokenFilterIA_PD : public virtual TokenOption {
public:
    TokenFilterIA_PD(const RepresentationType& rep_type) : TokenOption({ D6O_IA_PD }, rep_type) {
    }

    virtual OptionPtr getOption(Pkt&) {
        return (OptionPtr());
    }
};

class TokenLeaseIA_PDSuboption : public virtual TokenLeaseIA_PD {
public:
    TokenLeaseIA_PDSuboption(const Lease6Ptr& lease, const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_PD, D6O_IAPREFIX }, rep_type),
      TokenLeaseIA_PD(lease, rep_type) {
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        OptionPtr option = TokenLeaseIA_PD::getOption(pkt);
        if (option) {
            option = option->getOption(D6O_IAPREFIX);
        }
        return (option);
    }

    unsigned evaluate(Pkt& pkt, ValueStack& values) {
        return (TokenOption::evaluate(pkt, values));
    }
};

class TokenFilterIA_PDSuboption : public virtual TokenFilterIA_PD {
public:
    TokenFilterIA_PDSuboption(const RepresentationType& rep_type)
    : TokenOption({ D6O_IA_PD, D6O_IAPREFIX }, rep_type),
      TokenFilterIA_PD(rep_type) {
    }

    virtual OptionPtr getOption(Pkt& pkt) {
        return (TokenFilterIA_PD::getOption(pkt));
    }

    unsigned evaluate(Pkt& pkt, ValueStack& values) {
        return (TokenOption::evaluate(pkt, values));
    }
};
 
} // namespace dhcp
} // namespace isc

void filterLeaseIA_NA(isc::dhcp::Expression& expression, const Lease6Ptr& lease) {
    for (size_t i = 0; i < expression.size(); ++i) {
        boost::shared_ptr<TokenOption> option = boost::dynamic_pointer_cast<TokenOption>(expression[i]);
        if (option) {
            if (option->getOptions()[0] == D6O_IA_NA) {
                if (option->getOptions().size() == 2U && option->getOptions()[1] == D6O_IAADDR) {
                    expression[i] = TokenPtr(new TokenLeaseIA_NASuboption(lease, option->getRepresentation()));
                } else if (option->getOptions().size() == 1U) {
                    expression[i] = TokenPtr(new TokenLeaseIA_NA(lease, option->getRepresentation()));
                }
                continue;
            }
            if (option->getOptions()[0] == D6O_IA_PD) {
                if (option->getOptions().size() == 2U && option->getOptions()[1] == D6O_IAPREFIX) {
                    expression[i] = TokenPtr(new TokenFilterIA_PDSuboption(option->getRepresentation()));
                } else if (option->getOptions().size() == 1U) {
                    expression[i] = TokenPtr(new TokenFilterIA_PD(option->getRepresentation()));
                }
                continue;
            }
        }
    }
}

void filterLeaseIA_PD(isc::dhcp::Expression& expression, const Lease6Ptr& lease) {
    for (size_t i = 0; i < expression.size(); ++i) {
        boost::shared_ptr<TokenOption> option = boost::dynamic_pointer_cast<TokenOption>(expression[i]);
        if (option) {
            if (option->getOptions()[0] == D6O_IA_NA) {
                if (option->getOptions().size() == 2U && option->getOptions()[1] == D6O_IAADDR) {
                    expression[i] = TokenPtr(new TokenFilterIA_NASuboption(option->getRepresentation()));
                } else if (option->getOptions().size() == 1U) {
                    expression[i] = TokenPtr(new TokenFilterIA_NA(option->getRepresentation()));
                }
                continue;
            }
            if (option->getOptions()[0] == D6O_IA_PD) {
                if (option->getOptions().size() == 2U && option->getOptions()[1] == D6O_IAPREFIX) {
                    expression[i] = TokenPtr(new TokenLeaseIA_PDSuboption(lease, option->getRepresentation()));
                } else if (option->getOptions().size() == 1U) {
                    expression[i] = TokenPtr(new TokenLeaseIA_PD(lease, option->getRepresentation()));
                }
                continue;
            }
        }
    }
}

void replaceTokensForLease(isc::dhcp::ExpressionPtr& expression,
                           const Lease6Ptr& lease) {
    // Copy the expression so that is can be safely modified.
    expression.reset(new isc::dhcp::Expression(*expression));
    if (lease->type_ == Lease::TYPE_NA) {
        filterLeaseIA_NA(*expression, lease);
    } else if (lease->type_ == Lease::TYPE_PD) {
        filterLeaseIA_PD(*expression, lease);
    }
}

bool getCustomEntry(CalloutHandle& handle, const Pkt6Ptr& query, const Pkt6Ptr& response,
                    const Lease6Ptr& lease, std::string& value) {
    bool using_custom_format = false;
    auto library = LegalLogMgrFactory::instance(handle.getCurrentLibrary());
    try {
        auto expression = library->getRequestFormatExpression();
        if (expression && query) {
            replaceTokensForLease(expression, lease);
 
            value = evaluateString(*expression, *query);
            using_custom_format = true;
        }
 
        expression = library->getResponseFormatExpression();
        if (expression && response) {
            replaceTokensForLease(expression, lease);
 
            value += evaluateString(*expression, *response);
            using_custom_format = true;
        }
    } catch (const std::exception& ex) {
        LOG_ERROR(legal_log_logger, LEGAL_LOG_LEASE6_RENDER_ERROR)
                  .arg(lease ? lease->addr_.toText() : "<none>")
                  .arg(lease && lease->duid_ ? lease->duid_->toText() : "<none>")
                  .arg(ex.what());
        value.clear();
        return (false);
    }
 
    return (using_custom_format);
}

/// @param lease DHCPv6 lease for which the entry should be created
/// @param action Kind of event to log.
std::string genLease6Entry(CalloutHandle& handle,
                           const Pkt6Ptr& query,
                           const Pkt6Ptr& response,
                           const Lease6Ptr& lease,
                           const Action& action) {
    std::string value;
    if (getCustomEntry(handle, query, response, lease, value)) {
        return (value);
    }
 
    std::stringstream stream;
 
    // <address>
    if (lease->type_ != Lease::TYPE_PD) {
        stream << "Address: " << lease->addr_;
    } else {
        stream << "Prefix: " << lease->addr_ << "/" << static_cast<int>(lease->prefixlen_);
    }
 
    stream << " has been " << actionToVerb(action);
 
    if (action != Action::RELEASE) {
        // <duration>
        stream << " for " << LegalLogMgr::genDurationString(lease->valid_lft_) << " to";
    } else {
        stream << " from";
    }
 
    // <device-id>
    stream << " a device with DUID: " << lease->duid_->toText();
 
    if (lease->hwaddr_) {
        stream << " and hardware address: " << lease->hwaddr_->toText()
               << " (from " << hwaddrSourceToString(lease->hwaddr_->source_) << ")";
    }
 
    // Is it via relay(s)?
    if (query->relay_info_.size()) {
        const Pkt6::RelayInfo& server_relay = query->relay_info_[0];
        stream << " connected via relay at address: " << server_relay.peeraddr_.toText()
               << " for client on link address: " << server_relay.linkaddr_.toText()
               << ", hop count: " << static_cast<int>(server_relay.hop_count_);
 
        std::ostringstream idstream;
        // Look for the remote-id option
        OptionPtr opt = query->getAnyRelayOption(D6O_REMOTE_ID,
                                                 Pkt6::RELAY_SEARCH_FROM_CLIENT);
        if (opt) {
            const OptionBuffer id = opt->getData();
            if (!id.empty()) {
                idstream << "remote-id: " << dumpAsHex(id);
 
                if (isPrintable(id)) {
                    idstream << " (" << LegalLogMgr::vectorDump(id) << ")";
                }
            }
        }
 
        // Look for the subscriber-id option
        opt = query->getAnyRelayOption(D6O_SUBSCRIBER_ID,
                                       Pkt6::RELAY_SEARCH_FROM_CLIENT);
        if (opt) {
            const OptionBuffer id = opt->getData();
            if (!id.empty()) {
                if (!idstream.str().empty()) {
                    idstream << " and ";
                }
 
                idstream << "subscriber-id: " << dumpAsHex(id);
 
                if (isPrintable(id)) {
                    idstream << " (" << LegalLogMgr::vectorDump(id) << ")";
                }
            }
        }
 
        if (!idstream.str().empty()) {
            stream << ", identified by " << idstream.str();
        }
 
        // Look for the interface-id option
        std::ostringstream location;
        opt = query->getAnyRelayOption(D6O_INTERFACE_ID,
                                       Pkt6::RELAY_SEARCH_FROM_CLIENT);
        if (opt) {
            const OptionBuffer id = opt->getData();
            if (!id.empty()) {
                if (!idstream.str().empty()) {
                    idstream << " and ";
                }
 
                location << "interface-id: " << dumpAsHex(id);
 
                if (isPrintable(id)) {
                    location << " (" << LegalLogMgr::vectorDump(id) << ")";
                }
            }
        }
 
        if (!location.str().empty()) {
            stream << ", connected at location " << location.str();
        }
 
    }
 
    ConstElementPtr ctx = lease->getContext();
    if (ctx) {
        stream << ", context: " << ctx->str();
    }
 
    return (stream.str());
}

///
/// @return returns 0 upon success, non-zero otherwise
int legalLog6Handler(CalloutHandle& handle, const Action& action) {
    if (!LegalLogMgrFactory::instance(handle.getCurrentLibrary())) {
        LOG_ERROR(legal_log_logger, LEGAL_LOG_LEASE6_NO_LEGAL_STORE);
        return (1);
    }
 
    // Fetch the client's packet and the lease callout arguments.
    Pkt6Ptr query;
    handle.getArgument("query6", query);
 
    Pkt6Ptr response;
    handle.getArgument("response6", response);
 
    Lease6Ptr lease;
    handle.getContext("lease6", lease);
 
    if (!lease) {
        return (0);
    }
 
    ConstCfgSubnets6Ptr cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets6();
    try {
        ConstSubnet6Ptr subnet = cfg->getBySubnetId(lease->subnet_id_);
 
        if (!isLoggingDisabled(subnet)) {
            LegalLogMgrFactory::instance(handle.getCurrentLibrary())->writeln(genLease6Entry(handle, query, response,
                                                                                              lease, action),
                                                                               genLease6Addr(lease));
        }
 
    } catch (const std::exception& ex) {
        LOG_ERROR(legal_log_logger, LEGAL_LOG_LEASE6_WRITE_ERROR)
                  .arg(ex.what());
        return (1);
    }
 
    return (0);
}
 
// Functions accessed by the hooks framework use C linkage to avoid the name
// mangling that accompanies use of the C++ compiler as well as to avoid
// issues related to namespaces.
extern "C" {

///
/// @return 0 upon success, non-zero otherwise.
int pkt6_receive(CalloutHandle& handle) {
    handle.setContext("lease6", Lease4Ptr());
    handle.setContext("leases6", Lease6CollectionPtr());
    handle.setContext("deleted_leases6", Lease6CollectionPtr());
    return (0);
}

///
/// @return 0 upon success, non-zero otherwise.
int leases6_committed(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease6CollectionPtr leases;
    handle.getArgument("leases6", leases);
    handle.setContext("leases6", leases);
 
    Lease6CollectionPtr deleted_leases;
    handle.getArgument("deleted_leases6", deleted_leases);
    handle.setContext("deleted_leases6", deleted_leases);
    return (0);
}

///
/// @return 0 upon success, non-zero otherwise.
int pkt6_send(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease6CollectionPtr leases;
    handle.getContext("leases6", leases);
 
    int current = 0;
    int result = current;
 
    if (leases) {
        for (auto const& lease : *leases) {
            handle.setContext("lease6", lease);
            current = legalLog6Handler(handle, Action::ASSIGN);
            if (current) {
                result = current;
            }
        }
    }
 
    handle.getContext("deleted_leases6", leases);
 
    if (leases) {
        for (auto const& lease : *leases) {
            handle.setContext("lease6", lease);
            current = legalLog6Handler(handle, Action::RELEASE);
            if (current) {
                result = current;
            }
        }
    }
 
    return (result);
}

///
/// @return 0 upon success, non-zero otherwise.
int lease6_release(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease6Ptr lease;
    handle.getArgument("lease6", lease);
 
    Lease6CollectionPtr leases(new Lease6Collection());
    handle.setContext("leases6", leases);
 
    Lease6CollectionPtr deleted_leases(new Lease6Collection());
    deleted_leases->push_back(lease);
    handle.setContext("deleted_leases6", deleted_leases);
 
    return (0);
}

///
/// @return 0 upon success, non-zero otherwise.
int lease6_decline(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease6Ptr lease;
    handle.getArgument("lease6", lease);
 
    Lease6CollectionPtr leases(new Lease6Collection());
    handle.setContext("leases6", leases);
 
    Lease6CollectionPtr deleted_leases(new Lease6Collection());
    deleted_leases->push_back(lease);
    handle.setContext("deleted_leases6", deleted_leases);
 
    return (0);
}
 
} // end extern "C"