allocator.h

Go to the documentation of this file.

// Copyright (C) 2022-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/.
 
#ifndef ALLOCATOR_H
#define ALLOCATOR_H
 
#include <asiolink/io_address.h>
#include <dhcp/classify.h>
#include <dhcp/duid.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/pool.h>
#include <dhcpsrv/subnet_id.h>
#include <exceptions/exceptions.h>
#include <util/multi_threading_mgr.h>
 
#include <cstdint>
#include <mutex>
 
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
 
namespace isc {
namespace dhcp {

class Subnet;

typedef boost::weak_ptr<Subnet> WeakSubnetPtr;

class AllocFailed : public Exception {
public:

    AllocFailed(const char* file, size_t line, const char* what)
        : Exception(file, line, what) {}
};

class Allocator {
public:

    enum PrefixLenMatchType : uint16_t {
        PREFIX_LEN_EQUAL,      // select PD-pools with specific prefix length
        PREFIX_LEN_LOWER,      // select PD-pools with lower prefix length
        PREFIX_LEN_HIGHER      // select PD-pools with higher prefix length
    };

    Allocator(Lease::Type type, const WeakSubnetPtr& subnet);

    virtual ~Allocator();

    virtual std::string getType() const = 0;

    virtual isc::asiolink::IOAddress
    pickAddress(const ClientClasses& client_classes,
                const IdentifierBaseTypePtr& duid,
                const asiolink::IOAddress& hint) {
        util::MultiThreadingLock lock(mutex_);
        return (pickAddressInternal(client_classes, duid, hint));
    }

    virtual isc::asiolink::IOAddress
    pickPrefix(const ClientClasses& client_classes,
               Pool6Ptr& pool,
               const IdentifierBaseTypePtr& duid,
               PrefixLenMatchType prefix_length_match,
               const asiolink::IOAddress& hint,
               uint8_t hint_prefix_length) {
        util::MultiThreadingLock lock(mutex_);
        return (pickPrefixInternal(client_classes, pool, duid,
                                   prefix_length_match, hint,
                                   hint_prefix_length));
    }

    virtual double
    getOccupancyRate(const asiolink::IOAddress& addr,
                     const ClientClasses& client_classes);

    virtual double
    getOccupancyRate(const asiolink::IOAddress& pref,
                     const uint8_t plen,
                     const ClientClasses& client_classes);

    static bool isValidPrefixPool(Allocator::PrefixLenMatchType prefix_length_match,
                                  PoolPtr pool, uint8_t hint_prefix_length);

    void initAfterConfigure();
 
protected:

    virtual void initAfterConfigureInternal() {}
 
private:

    virtual isc::asiolink::IOAddress
    pickAddressInternal(const ClientClasses& client_classes,
                        const IdentifierBaseTypePtr& duid,
                        const isc::asiolink::IOAddress& hint) = 0;

    virtual isc::asiolink::IOAddress
    pickPrefixInternal(const ClientClasses& client_classes,
                       Pool6Ptr& pool,
                       const IdentifierBaseTypePtr& duid,
                       PrefixLenMatchType prefix_length_match,
                       const isc::asiolink::IOAddress& hint,
                       uint8_t hint_prefix_length) = 0;
 
protected:

    bool inited_;

    Lease::Type pool_type_;

    SubnetID subnet_id_;

    WeakSubnetPtr subnet_;

    std::mutex mutex_;
};

typedef boost::shared_ptr<Allocator> AllocatorPtr;
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // ALLOCATOR_H