alloc_engine.h

Go to the documentation of this file.

// Copyright (C) 2012-2023 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(uint64_t attempts);
 
    virtual ~AllocEngine() { }
 
private:
 
    uint64_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_;
 
        Subnet6Ptr subnet_;
 
        Subnet6Ptr 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_;
 
            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());
        }
 
        void createIAContext() {
            ias_.push_back(IAContext());
        };
 
        ConstHostPtr currentHost() const;
 
        ConstHostPtr globalHost() const;
 
        bool hasGlobalReservation(const IPv6Resrv& resv) const;
 
        ClientContext6();
 
        ClientContext6(const Subnet6Ptr& 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);
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,
                                Subnet6Ptr 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_;
 
        Subnet4Ptr 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 Subnet4Ptr& 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 uint32_t getOfferLft(const ClientContext4& ctx);
 
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(SubnetPtr subnet);
};
 
typedef boost::shared_ptr<AllocEngine> AllocEnginePtr;
 
}  // namespace dhcp
}  // namespace isc
 
#endif // ALLOC_ENGINE_H