ddns_tuning.h

Go to the documentation of this file.

// Copyright (C) 2022-2025 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/.
 
#ifndef DDNS_TUNING_H
#define DDNS_TUNING_H
 
#include <cc/base_stamped_element.h>
#include <cc/data.h>
#include <ddns_tuning_log.h>
#include <dhcpsrv/cfgmgr.h>
#include <dhcp/libdhcp++.h>
#include <dhcp/option.h>
#include <eval/evaluate.h>
#include <eval/token.h>
#include <dhcpsrv/subnet.h>
#include <expression_cache.h>
 
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
 
#include <map>
#include <string>
 
namespace isc {
namespace ddns_tuning {

class DdnsTuningImpl {
public:
    DdnsTuningImpl(uint16_t family = AF_INET) : family_(family) {
    }

    ~DdnsTuningImpl();

    void configure(isc::data::ConstElementPtr params);

    dhcp::ExpressionPtr getGlobalHostnameExpression();

    void setGlobalHostnameExpression(dhcp::ExpressionPtr& expression);

    dhcp::ExpressionPtr getHostnameExpression(const dhcp::SubnetID& subnet_id);

    void setHostnameExpression(const dhcp::SubnetID& subnet_id, dhcp::ExpressionPtr& expression);

    dhcp::ExpressionPtr fetchScopedHostnameExpression(dhcp::ConstSubnetPtr subnet);

    dhcp::ExpressionPtr cacheExpression(dhcp::ConstSubnetPtr subnet);

    dhcp::ExpressionPtr parseExpression(const std::string& expression_str) const;

    std::string calculateHostname(dhcp::PktPtr query,
                                  dhcp::ConstSubnetPtr subnet);

    void flushCache(bool preserve_global = true);

    size_t getCacheSize();

    boost::posix_time::ptime getLastFlushTime();

    uint16_t getFamily() {
        return (family_);
    }

    template<typename CfgSubnetPtrType>
    int repopulateCache(const CfgSubnetPtrType cfg_subnets) {
        size_t err_count = 0;
        flushCache();
        auto const& subnets = cfg_subnets->getAll();
        for (auto const& subnet : *subnets) {
            try {
                static_cast<void>(cacheExpression(subnet));
            } catch (const std::exception& ex) {
                // Log it but keep going, so we find all that are invalid.
                LOG_ERROR(ddns_tuning_logger, DDNS_TUNING_SUBNET_EXPRESSION_PARSE_ERROR)
                        .arg(subnet->toText()).arg(ex.what());
                ++err_count;
            }
        }
 
        return (err_count);
    }
 
private:
    uint16_t family_;
 
protected:
    ExpressionCache subnet_exprs_;
};

typedef boost::shared_ptr<DdnsTuningImpl> DdnsTuningImplPtr;
 
} // end of namespace ddns_tuning
} // end of namespace isc
#endif