configuration.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 ISC_LIMITS_CONFIGURATION_H
#define ISC_LIMITS_CONFIGURATION_H
 
#include <cc/base_stamped_element.h>
#include <cc/data.h>
#include <dhcp/classify.h>
#include <dhcpsrv/srv_config.h>
#include <dhcpsrv/subnet_id.h>
 
#include <limits>
 
namespace isc {
namespace limits {

template <typename limit_t>
static void checkForLimitBoundaries(int64_t const limit) {
    if (limit < 0) {
        isc_throw(ConfigError,
                  "expected positive limit configured, got negative limit " << limit);
    }
 
    if (std::numeric_limits<limit_t>::max() < limit) {
        isc_throw(ConfigError, "expected limit in range [0, "
                                              << std::numeric_limits<limit_t>::max()
                                              << "], got limit " << limit);
    }
}

using LeaseLimit = uint32_t;

struct RateLimit {
    RateLimit() : allowed_packets_(0) {
    }

    RateLimit(std::string const& text);

    uint32_t allowed_packets_;

    std::chrono::seconds time_unit_;

    std::string text_;
};

template <typename limit_t>
struct Configuration {
    virtual ~Configuration() = default;

    void parse(isc::dhcp::SrvConfigPtr const& config) {
        if (config) {
            // Check limits for all client classes.
            isc::dhcp::ClientClassDefListPtr const& client_classes(
                config->getClientClassDictionary()->getClasses());
            for (isc::dhcp::ClientClassDefPtr const& c : *client_classes) {
                logClientClassLimit(c->getName(), parseUserContext(c->getContext()));
            }
 
            // Check limits for all v4 subnets.
            isc::dhcp::Subnet4Collection const* const subnets4(config->getCfgSubnets4()->getAll());
            for (isc::dhcp::Subnet4Ptr const& s : *subnets4) {
                logSubnetLimit(s->getID(), parseUserContext(s->getContext()));
            }
 
            // Check limits for all v6 subnets.
            isc::dhcp::Subnet6Collection const* const subnets6(config->getCfgSubnets6()->getAll());
            for (isc::dhcp::Subnet6Ptr const& s : *subnets6) {
                logSubnetLimit(s->getID(), parseUserContext(s->getContext()));
            }
        }
    }

    isc::data::ConstElementPtr const
    parseUserContext(isc::data::ConstElementPtr const& user_context) const {
        if (!user_context) {
            return (isc::data::ConstElementPtr());
        }
        isc::data::ConstElementPtr const& limits(user_context->get("limits"));
        if (!limits) {
            return (isc::data::ConstElementPtr());
        }
        return (limits->get(key()));
    }

    virtual const std::string& key() const = 0;

    virtual void logClientClassLimit(isc::dhcp::ClientClass const& client_class,
                                     isc::data::ConstElementPtr const& user_context) = 0;

    virtual void logSubnetLimit(isc::dhcp::SubnetID const subnet_id,
                                isc::data::ConstElementPtr const& user_context) = 0;
};

struct AddressLimitConfiguration : Configuration<LeaseLimit> {
    const std::string& key() const override;

    virtual void logClientClassLimit(isc::dhcp::ClientClass const& client_class,
                                     isc::data::ConstElementPtr const& user_context) override;

    virtual void logSubnetLimit(isc::dhcp::SubnetID const subnet_id,
                                isc::data::ConstElementPtr const& user_context) override;
};

struct PrefixLimitConfiguration : Configuration<LeaseLimit> {
    const std::string& key() const override;

    virtual void logClientClassLimit(isc::dhcp::ClientClass const& client_class,
                                     isc::data::ConstElementPtr const& user_context) override;

    virtual void logSubnetLimit(isc::dhcp::SubnetID const subnet_id,
                                isc::data::ConstElementPtr const& user_context) override;
};

struct RateLimitConfiguration : Configuration<RateLimit> {
    const std::string& key() const override;

    virtual void logClientClassLimit(isc::dhcp::ClientClass const& client_class,
                                     isc::data::ConstElementPtr const& user_context) override;

    virtual void logSubnetLimit(isc::dhcp::SubnetID const subnet_id,
                                isc::data::ConstElementPtr const& user_context) override;
};
 
}  // namespace limits
}  // namespace isc
 
#endif  // ISC_LIMITS_CONFIGURATION_H