lease4_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/pkt4.h>
#include <dhcpsrv/cfg_subnets4.h>
#include <dhcpsrv/cfgmgr.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/legal_log_mgr_factory.h>
#include <eval/evaluate.h>
#include <forensic_log/legal_log_log.h>
#include <hooks/hooks.h>
#include <util/str.h>
 
#include <sstream>
 
#include <subnets_user_context.h>
 
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;

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

/// @param lease DHCPv4 lease for which the entry should be created
/// @param action Kind of event to log.
std::string genLease4Entry(CalloutHandle& handle,
                           const Pkt4Ptr& query,
                           const Pkt4Ptr& response,
                           const Lease4Ptr& lease,
                           const Action& action) {
    std::string value;
    if (getCustomEntry(handle, query, response, lease, value)) {
        return (value);
    }
 
    std::stringstream stream;
 
    // <address>
    stream << "Address: " << lease->addr_ << " 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 hardware address: " << lease->hwaddr_->toText();
 
    // <client-info>
    if (lease->client_id_) {
        stream << ", client-id: " << lease->client_id_->toText();
 
        // It is not uncommon to provide a printable client ID
        auto bin = lease->client_id_->getClientId();
 
        if (isPrintable(bin)) {
            stream << " (" << LegalLogMgr::vectorDump(bin) << ")";
        }
    }
 
    // <relay-info>
    const isc::asiolink::IOAddress& giaddr = query->getGiaddr();
    if (!giaddr.isV4Zero()) {
        stream << " connected via relay at address: " << giaddr.toText();
 
        // Look for relay agent information option (option 82)
        OptionPtr rai = query->getOption(DHO_DHCP_AGENT_OPTIONS);
        if (rai) {
            // Look for circuit-id (sub-option 1)
            std::stringstream idstream;
            OptionPtr opt = rai->getOption(RAI_OPTION_AGENT_CIRCUIT_ID);
            if (opt) {
                const OptionBuffer& id = opt->getData();
                if (!id.empty()) {
                    idstream << "circuit-id: " << dumpAsHex(id);
 
                    if (isPrintable(id)) {
                        idstream << " (" << LegalLogMgr::vectorDump(id) << ")";
                    }
                }
            }
 
            // Look for remote-id (sub-option 2)
            opt = rai->getOption(RAI_OPTION_REMOTE_ID);
            if (opt) {
                const OptionBuffer& id = opt->getData();
                if (!id.empty()) {
                    if (!idstream.str().empty()) {
                        idstream << " and ";
                    }
 
                    idstream << "remote-id: " << dumpAsHex(id);
 
                    if (isPrintable(id)) {
                        idstream << " (" << LegalLogMgr::vectorDump(id) << ")";
                    }
                }
            }
 
            // Look for subscriber-id (sub-option 6)
            opt = rai->getOption(RAI_OPTION_SUBSCRIBER_ID);
            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();
            }
        }
    }
 
    ConstElementPtr ctx = lease->getContext();
    if (ctx) {
        stream << ", context: " << ctx->str();
    }
 
    return (stream.str());
}

///
/// @return returns 0 upon success, non-zero otherwise
int legalLog4Handler(CalloutHandle& handle, const Action& action) {
    if (!LegalLogMgrFactory::instance(handle.getCurrentLibrary())) {
        LOG_ERROR(legal_log_logger,
                  LEGAL_LOG_LEASE4_NO_LEGAL_STORE);
        return (1);
    }
 
    // Fetch the client's packet and the lease callout arguments.
    Pkt4Ptr query;
    handle.getArgument("query4", query);
 
    Pkt4Ptr response;
    handle.getArgument("response4", response);
 
    Lease4Ptr lease;
    handle.getContext("lease4", lease);
 
    if (!lease) {
        return (0);
    }
 
    ConstCfgSubnets4Ptr cfg = CfgMgr::instance().getCurrentCfg()->getCfgSubnets4();
    try {
        ConstSubnet4Ptr subnet = cfg->getBySubnetId(lease->subnet_id_);
 
        if (!isLoggingDisabled(subnet)) {
            LegalLogMgrFactory::instance(handle.getCurrentLibrary())->writeln(genLease4Entry(handle, query, response,
                                                                                              lease, action),
                                                                               lease->addr_.toText());
        }
 
    } catch (const std::exception& ex) {
        LOG_ERROR(legal_log_logger, LEGAL_LOG_LEASE4_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 pkt4_receive(CalloutHandle& handle) {
    handle.setContext("lease4", Lease4Ptr());
    handle.setContext("leases4", Lease4CollectionPtr());
    handle.setContext("deleted_leases4", Lease4CollectionPtr());
    return (0);
}

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

///
/// @return 0 upon success, non-zero otherwise.
int pkt4_send(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease4CollectionPtr leases;
    handle.getContext("leases4", leases);
 
    int current = 0;
    int result = current;
 
    if (leases) {
        for (auto const& lease : *leases) {
            handle.setContext("lease4", lease);
            current = legalLog4Handler(handle, Action::ASSIGN);
            if (current) {
                result = current;
            }
        }
    }
 
    handle.getContext("deleted_leases4", leases);
 
    if (leases) {
        for (auto const& lease : *leases) {
            handle.setContext("lease4", lease);
            current = legalLog4Handler(handle, Action::RELEASE);
            if (current) {
                result = current;
            }
        }
    }
 
    return (result);
}

///
/// @return 0 upon success, non-zero otherwise.
int lease4_release(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease4Ptr lease;
    handle.getArgument("lease4", lease);
    handle.setContext("lease4", lease);
 
    Pkt4Ptr response;
    handle.setArgument("response4", response);
 
    return (legalLog4Handler(handle, Action::RELEASE));
}

///
/// @return 0 upon success, non-zero otherwise.
int lease4_decline(CalloutHandle& handle) {
    CalloutHandle::CalloutNextStep status = handle.getStatus();
    if (status == CalloutHandle::NEXT_STEP_DROP ||
        status == CalloutHandle::NEXT_STEP_SKIP) {
        return (0);
    }
 
    Lease4Ptr lease;
    handle.getArgument("lease4", lease);
    handle.setContext("lease4", lease);
 
    Pkt4Ptr response;
    handle.setArgument("response4", response);
 
    return (legalLog4Handler(handle, Action::RELEASE));
}
 
} // end extern "C"