alloc_engine.h

Go to the documentation of this file.

// Copyright (C) 2012-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 ALLOC_ENGINE_H
#define ALLOC_ENGINE_H
 
#include <asiolink/io_address.h>
#include <dhcp/classify.h>
#include <dhcp/duid.h>
#include <dhcp/hwaddr.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <dhcp/option6_ia.h>
#include <dhcp/option6_iaaddr.h>
#include <dhcp/option6_iaprefix.h>
#include <dhcpsrv/allocator.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <dhcpsrv/host.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/srv_config.h>
#include <hooks/callout_handle.h>
#include <util/multi_threading_mgr.h>
#include <util/readwrite_mutex.h>
 
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
 
#include <functional>
#include <list>
#include <map>
#include <mutex>
#include <set>
#include <utility>
 
namespace isc {
namespace dhcp {

class AllocEngine : public boost::noncopyable {
public:

    AllocEngine(isc::util::uint128_t const& attempts);

    virtual ~AllocEngine() { }
 
private:

    isc::util::uint128_t attempts_;

    int hook_index_lease4_select_; 
    int hook_index_lease6_select_; 
 
public:

    class Resource {
    public:

        Resource(const isc::asiolink::IOAddress& address,
                 const uint8_t prefix_len = 128,
                 const uint32_t preferred = 0,
                 const uint32_t valid = 0)
            : address_(address), prefix_len_(prefix_len),
              preferred_(preferred), valid_(valid) {
        }

        isc::asiolink::IOAddress getAddress() const {
            return (address_);
        }

        uint8_t getPrefixLength() const {
            return (prefix_len_);
        }

        uint32_t getPreferred() const {
            return (preferred_);
        }

        uint32_t getValid() const {
            return (valid_);
        }

        bool equals(const Resource& other) const {
            return (address_ == other.address_ &&
                    prefix_len_ == other.prefix_len_);
        }

        bool operator==(const Resource& other) const {
            return (equals(other));
        }
 
    protected:

        isc::asiolink::IOAddress address_;

        uint8_t prefix_len_;

        uint32_t preferred_;

        uint32_t valid_;
    };

    struct ResourceCompare {
        bool operator() (const Resource& lhr, const Resource& rhr) const {
            if (lhr.getAddress() == rhr.getAddress()) {
                return (lhr.getPrefixLength() < rhr.getPrefixLength());
            } else {
                return (lhr.getAddress() < rhr.getAddress());
            }
        }
    };

    typedef std::vector<Resource> HintContainer;

    typedef std::set<Resource, ResourceCompare> ResourceContainer;

    typedef std::pair<Host::IdentifierType, std::vector<uint8_t> > IdentifierPair;

    typedef std::list<IdentifierPair> IdentifierList;

    struct ClientContext6 : public boost::noncopyable {



        Pkt6Ptr query_;

        bool fake_allocation_;

        bool early_global_reservations_lookup_;

        ConstSubnet6Ptr subnet_;

        ConstSubnet6Ptr host_subnet_;

        DuidPtr duid_;

        HWAddrPtr hwaddr_;

        IdentifierList host_identifiers_;

        std::map<SubnetID, ConstHostPtr> hosts_;

        bool fwd_dns_update_;

        bool rev_dns_update_;

        std::string hostname_;

        hooks::CalloutHandlePtr callout_handle_;

        ResourceContainer allocated_resources_;

        Lease6Collection new_leases_;


        struct IAContext {

            uint32_t iaid_;

            Lease::Type type_;

            HintContainer hints_;

            Lease6Collection old_leases_;

            Lease6Collection changed_leases_;

            Lease6Collection reused_leases_;

            ResourceContainer new_resources_;

            Option6IAPtr ia_rsp_;

            IAContext();

            void addHint(const asiolink::IOAddress& prefix,
                         const uint8_t prefix_len = 128,
                         const uint32_t preferred = 0,
                         const uint32_t valid = 0);

            void addHint(const Option6IAAddrPtr& iaaddr);

            void addHint(const Option6IAPrefixPtr& iaprefix);

            void addNewResource(const asiolink::IOAddress& prefix,
                                const uint8_t prefix_len = 128);

            bool isNewResource(const asiolink::IOAddress& prefix,
                               const uint8_t prefix_len = 128) const;
        };

        std::vector<IAContext> ias_;

        DdnsParamsPtr getDdnsParams();

        void addAllocatedResource(const asiolink::IOAddress& prefix,
                                  const uint8_t prefix_len = 128);

        bool isAllocated(const asiolink::IOAddress& prefix,
                         const uint8_t prefix_len = 128) const;

        void addHostIdentifier(const Host::IdentifierType& id_type,
                               const std::vector<uint8_t>& identifier) {
            host_identifiers_.push_back(IdentifierPair(id_type, identifier));
        }

        IAContext& currentIA() {
            if (ias_.empty()) {
                createIAContext();
            }
            return (ias_.back());
        }
 
        std::vector<IAContext>& getIAContexts() {
            return (ias_);
        }

        void createIAContext() {
            ias_.push_back(IAContext());
        }

        ConstHostPtr currentHost() const;

        ConstHostPtr globalHost() const;

        bool hasGlobalReservation(const IPv6Resrv& resv) const;

        ClientContext6();

        ClientContext6(const ConstSubnet6Ptr& subnet, const DuidPtr& duid,
                       const bool fwd_dns, const bool rev_dns,
                       const std::string& hostname, const bool fake_allocation,
                       const Pkt6Ptr& query,
                       const hooks::CalloutHandlePtr& callout_handle =
                       hooks::CalloutHandlePtr());
 
        private:
            DdnsParamsPtr ddns_params_;
    };

    Lease6Collection
    allocateLeases6(ClientContext6& ctx);

    Lease6Collection renewLeases6(ClientContext6& ctx);

    void reclaimExpiredLeases6(const size_t max_leases, const uint16_t timeout,
                               const bool remove_lease,
                               const uint16_t max_unwarned_cycles = 0);

    void reclaimExpiredLeases6Internal(const size_t max_leases,
                                       const uint16_t timeout,
                                       const bool remove_lease,
                                       const uint16_t max_unwarned_cycles = 0);

    void deleteExpiredReclaimedLeases6(const uint32_t secs);

    void reclaimExpiredLeases4(const size_t max_leases, const uint16_t timeout,
                               const bool remove_lease,
                               const uint16_t max_unwarned_cycles = 0);

    void reclaimExpiredLeases4Internal(const size_t max_leases,
                                       const uint16_t timeout,
                                       const bool remove_lease,
                                       const uint16_t max_unwarned_cycles = 0);

    void deleteExpiredReclaimedLeases4(const uint32_t secs);

    static void findReservation(ClientContext6& ctx);

    static ConstHostPtr findGlobalReservation(ClientContext6& ctx);

    static IPv6Resrv makeIPv6Resrv(const Lease6& lease) {
        if (lease.type_ == Lease::TYPE_NA) {
            return (IPv6Resrv(IPv6Resrv::TYPE_NA, lease.addr_,
                              (lease.prefixlen_ ? lease.prefixlen_ : 128)));
        }
 
        return (IPv6Resrv(IPv6Resrv::TYPE_PD, lease.addr_, lease.prefixlen_));
    }
 
public:
    static void getLifetimes6(ClientContext6& ctx, uint32_t& preferred,
                              uint32_t& valid);

    static void getMinLifetimes6(ClientContext6& ctx, uint32_t& preferred,
                                 uint32_t& valid);
private:

    Lease6Ptr createLease6(ClientContext6& ctx,
                           const isc::asiolink::IOAddress& addr,
                           const uint8_t prefix_len,
                           hooks::CalloutHandle::CalloutNextStep& callout_status);

    Lease6Collection allocateUnreservedLeases6(ClientContext6& ctx);

    Lease6Ptr allocateBestMatch(ClientContext6& ctx,
                                Lease6Ptr& hint_lease,
                                bool& search_hint_lease,
                                const isc::asiolink::IOAddress& hint,
                                uint8_t hint_prefix_length,
                                ConstSubnet6Ptr original_subnet,
                                SharedNetwork6Ptr& network,
                                uint64_t& total_attempts,
                                uint64_t& subnets_with_unavail_leases,
                                uint64_t& subnets_with_unavail_pools,
                                hooks::CalloutHandle::CalloutNextStep& callout_status,
                                Allocator::PrefixLenMatchType prefix_length_match);

    void
    allocateReservedLeases6(ClientContext6& ctx, Lease6Collection& existing_leases);

    void
    allocateGlobalReservedLeases6(ClientContext6& ctx, Lease6Collection& existing_leases);

    void
    removeNonmatchingReservedLeases6(ClientContext6& ctx,
                                     Lease6Collection& existing_leases);

    void
    removeNonmatchingReservedNoHostLeases6(ClientContext6& ctx,
                                           Lease6Collection& existing_leases);

    void
    removeNonreservedLeases6(ClientContext6& ctx,
                             Lease6Collection& existing_leases);

    Lease6Ptr
    reuseExpiredLease(Lease6Ptr& expired,
                      ClientContext6& ctx,
                      uint8_t prefix_len,
                      hooks::CalloutHandle::CalloutNextStep& callout_status);

    Lease6Collection updateLeaseData(ClientContext6& ctx,
                                     const Lease6Collection& leases);

    static bool
    removeLeases(Lease6Collection& container,
                 const asiolink::IOAddress& addr);

    void extendLease6(ClientContext6& ctx, Lease6Ptr lease);

    enum DbReclaimMode {
        DB_RECLAIM_REMOVE,
        DB_RECLAIM_UPDATE,
        DB_RECLAIM_LEAVE_UNCHANGED
    };

    template<typename LeasePtrType>
    void reclaimExpiredLease(const LeasePtrType& lease,
                             const bool remove_lease,
                             const hooks::CalloutHandlePtr& callout_handle);

    template<typename LeasePtrType>
    void reclaimExpiredLease(const LeasePtrType& lease,
                             const hooks::CalloutHandlePtr& callout_handle);

    void reclaimExpiredLease(const Lease6Ptr& lease,
                             const DbReclaimMode& reclaim_mode,
                             const hooks::CalloutHandlePtr& callout_handle);

    void reclaimExpiredLease(const Lease4Ptr& lease,
                             const DbReclaimMode& reclaim_mode,
                             const hooks::CalloutHandlePtr& callout_handle);

    template<typename LeasePtrType>
    void reclaimLeaseInDatabase(const LeasePtrType& lease,
                                const bool remove_lease,
                                const std::function<void (const LeasePtrType&)>&
                                lease_update_fun) const;

    bool reclaimDeclined(const Lease4Ptr& lease);

    bool reclaimDeclined(const Lease6Ptr& lease);
 
public:

    struct ClientContext4 : public boost::noncopyable {
        bool early_global_reservations_lookup_;

        ConstSubnet4Ptr subnet_;

        ClientIdPtr clientid_;

        HWAddrPtr hwaddr_;

        asiolink::IOAddress requested_address_;

        bool fwd_dns_update_;

        bool rev_dns_update_;

        std::string hostname_;

        hooks::CalloutHandlePtr callout_handle_;

        bool fake_allocation_;

        uint32_t offer_lft_;

        Lease4Ptr old_lease_;

        Lease4Ptr new_lease_;

        std::map<SubnetID, ConstHostPtr> hosts_;

        Lease4Ptr conflicting_lease_;

        Pkt4Ptr query_;

        IdentifierList host_identifiers_;

        bool unknown_requested_addr_;

        DdnsParamsPtr getDdnsParams();
 

        void addHostIdentifier(const Host::IdentifierType& id_type,
                               const std::vector<uint8_t>& identifier) {
            host_identifiers_.push_back(IdentifierPair(id_type, identifier));
        }

        ConstHostPtr currentHost() const;

        ConstHostPtr globalHost() const;

        ClientContext4();

        ClientContext4(const ConstSubnet4Ptr& subnet,
                       const ClientIdPtr& clientid,
                       const HWAddrPtr& hwaddr,
                       const asiolink::IOAddress& requested_addr,
                       const bool fwd_dns_update, const bool rev_dns_update,
                       const std::string& hostname, const bool fake_allocation,
                       const uint32_t offer_lft = 0);
        private:
            DdnsParamsPtr ddns_params_;
    };

    typedef boost::shared_ptr<ClientContext4> ClientContext4Ptr;

    Lease4Ptr allocateLease4(ClientContext4& ctx);

    static void findReservation(ClientContext4& ctx);

    static ConstHostPtr findGlobalReservation(ClientContext4& ctx);

    static uint32_t getValidLft(const ClientContext4& ctx);

    static void getMinValidLft(const ClientContext4& ctx, uint32_t& valid);

    static uint32_t getOfferLft(const ClientContext4& ctx,
                                bool only_on_discover = true);
    static void getRemaining(const Lease4Ptr& lease, uint32_t& valid);

    static void getRemaining(const Lease6Ptr& lease, uint32_t& preferred,
                             uint32_t& valid);
 
private:

    Lease4Ptr discoverLease4(ClientContext4& ctx);

    Lease4Ptr requestLease4(ClientContext4& ctx);

    Lease4Ptr createLease4(const ClientContext4& ctx,
                           const isc::asiolink::IOAddress& addr,
                           hooks::CalloutHandle::CalloutNextStep& callout_status);

    Lease4Ptr renewLease4(const Lease4Ptr& lease, ClientContext4& ctx);

    Lease4Ptr
    reuseExpiredLease4(Lease4Ptr& expired, ClientContext4& ctx,
                       hooks::CalloutHandle::CalloutNextStep& callout_status);

    Lease4Ptr
    allocateOrReuseLease4(const asiolink::IOAddress& address,
                          ClientContext4& ctx,
                          hooks::CalloutHandle::CalloutNextStep& callout_status);

    Lease4Ptr allocateUnreservedLease4(ClientContext4& ctx);

    bool updateLease4Information(const Lease4Ptr& lease,
                                 ClientContext4& ctx) const;
 
protected:
    bool updateLease4ExtendedInfo(const Lease4Ptr& lease,
                                  const ClientContext4& ctx) const;

    void updateLease6ExtendedInfo(const Lease6Ptr& lease,
                                  const ClientContext6& ctx) const;

    void clearReclaimedExtendedInfo(const Lease4Ptr& lease) const;

    void clearReclaimedExtendedInfo(const Lease6Ptr& lease) const;
 
private:

    void setLeaseReusable(const Lease4Ptr& lease,
                          const ClientContext4& ctx) const;

    void setLeaseReusable(const Lease6Ptr& lease,
                          uint32_t current_preferred_lft,
                          const ClientContext6& ctx) const;
 
private:

    uint16_t incomplete_v4_reclamations_;

    uint16_t incomplete_v6_reclamations_;
 
public:

    isc::util::ReadWriteMutex& getReadWriteMutex() {
        return (rw_mutex_);
    }

    isc::util::ReadWriteMutex rw_mutex_;

    static std::string labelNetworkOrSubnet(ConstSubnetPtr subnet);
};

typedef boost::shared_ptr<AllocEngine> AllocEnginePtr;
 
}  // namespace dhcp
}  // namespace isc
 
#endif // ALLOC_ENGINE_H