alloc_engine.h

Go to the documentation of this file.

// Copyright (C) 2012-2021 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/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 AllocFailed : public isc::Exception {
public:

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

class AllocEngine : public boost::noncopyable {
protected:

    class Allocator {
    public:

        virtual isc::asiolink::IOAddress
        pickAddress(const SubnetPtr& subnet,
                    const ClientClasses& client_classes,
                    const DuidPtr& duid,
                    const isc::asiolink::IOAddress& hint) {
            if (isc::util::MultiThreadingMgr::instance().getMode()) {
                std::lock_guard<std::mutex> lock(mutex_);
                return pickAddressInternal(subnet, client_classes, duid, hint);
            } else {
                return pickAddressInternal(subnet, client_classes, duid, hint);
            }
        }

        Allocator(Lease::Type pool_type) : pool_type_(pool_type) {
        }

        virtual ~Allocator() {
        }

    private:
        virtual isc::asiolink::IOAddress
        pickAddressInternal(const SubnetPtr& subnet,
                            const ClientClasses& client_classes,
                            const DuidPtr& duid,
                            const isc::asiolink::IOAddress& hint) = 0;

    protected:

        Lease::Type pool_type_;

    private:

        std::mutex mutex_;
    };

    typedef boost::shared_ptr<Allocator> AllocatorPtr;

    class IterativeAllocator : public Allocator {
    public:

        IterativeAllocator(Lease::Type type);

    private:

        virtual isc::asiolink::IOAddress
        pickAddressInternal(const SubnetPtr& subnet,
                            const ClientClasses& client_classes,
                            const DuidPtr& duid,
                            const isc::asiolink::IOAddress& hint);

    protected:

        static isc::asiolink::IOAddress
        increasePrefix(const isc::asiolink::IOAddress& prefix,
                       const uint8_t prefix_len);

        static isc::asiolink::IOAddress
        increaseAddress(const isc::asiolink::IOAddress& address,
                        bool prefix, const uint8_t prefix_len);
    };

    class HashedAllocator : public Allocator {
    public:

        HashedAllocator(Lease::Type type);

    private:

        virtual isc::asiolink::IOAddress
        pickAddressInternal(const SubnetPtr& subnet,
                            const ClientClasses& client_classes,
                            const DuidPtr& duid,
                            const isc::asiolink::IOAddress& hint);
    };

    class RandomAllocator : public Allocator {
    public:

        RandomAllocator(Lease::Type type);

    private:

        virtual isc::asiolink::IOAddress
        pickAddressInternal(const SubnetPtr& subnet,
                            const ClientClasses& client_classes,
                            const DuidPtr& duid,
                            const isc::asiolink::IOAddress& hint);
    };

public:

    typedef enum {
        ALLOC_ITERATIVE, // iterative - one address after another
        ALLOC_HASHED,    // hashed - client's DUID/client-id is hashed
        ALLOC_RANDOM     // random - an address is randomly selected
    } AllocType;

    AllocEngine(AllocType engine_type, uint64_t attempts, bool ipv6 = true);

    virtual ~AllocEngine() { }

    AllocatorPtr getAllocator(Lease::Type type);

private:

    std::map<Lease::Type, AllocatorPtr> allocators_;

    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,
                 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_;

        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 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 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_));
    }

private:

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

    Lease6Collection allocateUnreservedLeases6(ClientContext6& ctx);

    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 {
        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_;

        Lease4Ptr old_lease_;

        Lease4Ptr new_lease_;

        std::map<SubnetID, ConstHostPtr> hosts_;

        Lease4Ptr conflicting_lease_;

        Pkt4Ptr query_;

        IdentifierList host_identifiers_;

        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);

        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);

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;

    bool updateLease6ExtendedInfo(const Lease6Ptr& lease,
                                  const ClientContext6& ctx) 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_;
};

typedef boost::shared_ptr<AllocEngine> AllocEnginePtr;

}  // namespace dhcp
}  // namespace isc

#endif // ALLOC_ENGINE_H