alloc_engine.h

Go to the documentation of this file.

// Copyright (C) 2012-2018 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 <dhcpsrv/host.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/lease_mgr.h>
#include <hooks/callout_handle.h>
 
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
 
#include <list>
#include <map>
#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) = 0;
 
        Allocator(Lease::Type pool_type)
            :pool_type_(pool_type) {
        }
 
        virtual ~Allocator() {
        }
    protected:
 
        Lease::Type pool_type_;
    };
 
    typedef boost::shared_ptr<Allocator> AllocatorPtr;
 
    class IterativeAllocator : public Allocator {
    public:
 
        IterativeAllocator(Lease::Type type);
 
        virtual isc::asiolink::IOAddress
            pickAddress(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);
 
        virtual isc::asiolink::IOAddress
            pickAddress(const SubnetPtr& subnet,
                        const ClientClasses& client_classes,
                        const DuidPtr& duid,
                        const isc::asiolink::IOAddress& hint);
    };
 
    class RandomAllocator : public Allocator {
    public:
 
        RandomAllocator(Lease::Type type);
 
        virtual isc::asiolink::IOAddress
        pickAddress(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_;
 
    // hook name indexes (used in hooks callouts)
    int hook_index_lease4_select_; 
    int hook_index_lease6_select_; 
 
public:
 
    typedef std::pair<isc::asiolink::IOAddress, uint8_t> ResourceType;
 
    typedef std::vector<ResourceType> HintContainer;
 
    typedef std::set<ResourceType> 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_;
 
            Option6IAPtr ia_rsp_;
 
            IAContext();
 
            void addHint(const asiolink::IOAddress& prefix,
                         const uint8_t prefix_len = 128);
        };
 
        std::vector<IAContext> ias_;
 
        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());
    };
 
    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);
 
    bool
    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 boost::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_;
 
        void addHostIdentifier(const Host::IdentifierType& id_type,
                               const std::vector<uint8_t>& identifier) {
            host_identifiers_.push_back(IdentifierPair(id_type, identifier));
        }
 
        ConstHostPtr currentHost() 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);
 
    };
 
    typedef boost::shared_ptr<ClientContext4> ClientContext4Ptr;
 
    Lease4Ptr allocateLease4(ClientContext4& ctx);
 
    static void findReservation(ClientContext4& ctx);
 
    static ConstHostPtr findGlobalReservation(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);
 
    void updateLease4Information(const Lease4Ptr& lease,
                                 ClientContext4& ctx) const;
 
    bool conditionalExtendLifetime(Lease& lease) const;
 
private:
 
    uint16_t incomplete_v4_reclamations_;
 
    uint16_t incomplete_v6_reclamations_;
};
 
typedef boost::shared_ptr<AllocEngine> AllocEnginePtr;
 
}; // namespace isc::dhcp
}; // namespace isc
 
#endif // ALLOC_ENGINE_H