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