lease_mgr.h

Go to the documentation of this file.

// Copyright (C) 2012-2026 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 LEASE_MGR_H
#define LEASE_MGR_H
 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <cc/data.h>
#include <database/database_connection.h>
#include <database/db_exceptions.h>
#include <dhcp/duid.h>
#include <dhcp/hwaddr.h>
#include <dhcp/option.h>
#include <dhcpsrv/cfg_consistency.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/subnet.h>
 
#include <cstdint>
#include <fstream>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>

namespace isc {
namespace dhcp {

typedef std::pair<uint32_t, uint32_t> VersionPair;

class LeasePageSize {
public:

    explicit LeasePageSize(const size_t page_size);
 
    const size_t page_size_; 
};

struct LeaseStatsRow {
    LeaseStatsRow() :
        subnet_id_(0), pool_id_(0), lease_type_(Lease::TYPE_NA),
        lease_state_(Lease::STATE_DEFAULT), state_count_(0) {
    }

    LeaseStatsRow(const SubnetID& subnet_id, const uint32_t lease_state,
                  const int64_t state_count, uint32_t pool_id = 0)
        : subnet_id_(subnet_id), pool_id_(pool_id), lease_type_(Lease::TYPE_NA),
          lease_state_(lease_state), state_count_(state_count) {
    }

    LeaseStatsRow(const SubnetID& subnet_id, const Lease::Type& lease_type,
                  const uint32_t lease_state, const int64_t state_count,
                  uint32_t pool_id = 0)
        : subnet_id_(subnet_id), pool_id_(pool_id), lease_type_(lease_type),
          lease_state_(lease_state), state_count_(state_count) {
    }

    bool operator<(const LeaseStatsRow &rhs) const {
        if (subnet_id_ < rhs.subnet_id_) {
            return (true);
        }
 
        if (subnet_id_ == rhs.subnet_id_ &&
            pool_id_ < rhs.pool_id_) {
            return (true);
        }
 
        if (subnet_id_ == rhs.subnet_id_ &&
            pool_id_ == rhs.pool_id_ &&
            lease_type_ < rhs.lease_type_) {
            return (true);
        }
 
        if (subnet_id_ == rhs.subnet_id_ &&
            pool_id_ == rhs.pool_id_ &&
            lease_type_ == rhs.lease_type_ &&
            lease_state_ < rhs.lease_state_) {
            return (true);
        }
 
        return (false);
    }

    SubnetID subnet_id_;

    uint32_t pool_id_;

    Lease::Type lease_type_;

    uint32_t lease_state_;

    int64_t state_count_;
};

class LeaseStatsQuery {
public:
    enum SelectMode : uint16_t {
        ALL_SUBNETS,
        SINGLE_SUBNET,
        SUBNET_RANGE,
        ALL_SUBNET_POOLS
    };

    LeaseStatsQuery(const SelectMode& select_mode = ALL_SUBNETS);

    LeaseStatsQuery(const SubnetID& subnet_id);

    LeaseStatsQuery(const SubnetID& first_subnet_id, const SubnetID& last_subnet_id);

    virtual ~LeaseStatsQuery() {}

    virtual void start() {}

    virtual bool getNextRow(LeaseStatsRow& row);

    SubnetID getFirstSubnetID() const {
        return (first_subnet_id_);
    }

    SubnetID getLastSubnetID() const {
        return (last_subnet_id_);
    }

    SelectMode getSelectMode() const {
        return (select_mode_);
    }
 
protected:
    SubnetID first_subnet_id_;

    SubnetID last_subnet_id_;
 
private:
    SelectMode select_mode_;
};

typedef boost::shared_ptr<LeaseStatsQuery> LeaseStatsQueryPtr;

typedef boost::shared_ptr<LeaseStatsRow> LeaseStatsRowPtr;

class SflqPoolInfo {
public:
    SflqPoolInfo();
 
    ~SflqPoolInfo(){};
 
    Lease::Type lease_type_;
    asiolink::IOAddress start_address_;
    asiolink::IOAddress end_address_;
    uint8_t delegated_len_;
    SubnetID subnet_id_;
    uint64_t free_leases_;
    boost::posix_time::ptime created_ts_;
    boost::posix_time::ptime modified_ts_;
 
    data::ElementPtr toElement() const;
};

typedef boost::shared_ptr<SflqPoolInfo> SflqPoolInfoPtr;

typedef std::vector<SflqPoolInfoPtr> SflqPoolInfoCollection;
typedef boost::shared_ptr<SflqPoolInfoCollection> SflqPoolInfoCollectionPtr;
 

class LeaseMgr {
public:
    LeaseMgr() : extended_info_tables_enabled_(false)
    {}

    virtual ~LeaseMgr()
    {}

    static std::string getDBVersion();

    virtual bool addLease(const Lease4Ptr& lease) = 0;

    virtual bool addLease(const Lease6Ptr& lease) = 0;

    virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress& addr) const = 0;

    virtual Lease4Collection getLease4(const isc::dhcp::HWAddr& hwaddr) const = 0;

    virtual Lease4Ptr getLease4(const isc::dhcp::HWAddr& hwaddr,
                                SubnetID subnet_id) const = 0;

    virtual Lease4Collection getLease4(const ClientId& clientid) const = 0;

    virtual Lease4Ptr getLease4(const ClientId& clientid,
                                SubnetID subnet_id) const = 0;

    virtual Lease4Collection getLeases4(SubnetID subnet_id) const = 0;

    virtual Lease4Collection getLeases4(const std::string& hostname) const = 0;

    virtual Lease4Collection getLeases4() const = 0;

    virtual Lease4Collection
    getLeases4(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const = 0;

    virtual Lease4Collection getLeases4(uint32_t state,
                                        SubnetID subnet_id) const = 0;

    virtual Lease6Ptr getLease6(Lease::Type type,
                                const isc::asiolink::IOAddress& addr) const = 0;

    virtual Lease6Collection getLease6(const isc::dhcp::HWAddr& hwaddr) const = 0;

    virtual Lease6Collection getLeases6(Lease::Type type, const DUID& duid,
                                        uint32_t iaid) const = 0;

    virtual Lease6Collection getLeases6(Lease::Type type, const DUID& duid,
                                        uint32_t iaid, SubnetID subnet_id) const = 0;

    Lease6Ptr getLease6(Lease::Type type, const DUID& duid,
                        uint32_t iaid, SubnetID subnet_id) const;

    virtual Lease6Collection getLeases6(SubnetID subnet_id) const = 0;

    virtual Lease6Collection getLeases6(const std::string& hostname) const = 0;

    virtual Lease6Collection getLeases6() const = 0;

    virtual Lease6Collection getLeases6(const DUID& duid) const = 0;

    virtual Lease6Collection
    getLeases6(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const = 0;

    virtual Lease6Collection
    getLeases6(SubnetID subnet_id,
               const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const = 0;

    virtual Lease6Collection getLeases6(uint32_t state,
                                        SubnetID subnet_id) const = 0;

    virtual void getExpiredLeases4(Lease4Collection& expired_leases,
                                   const size_t max_leases) const = 0;

    virtual void getExpiredLeases6(Lease6Collection& expired_leases,
                                   const size_t max_leases) const = 0;

    virtual void updateLease4(const Lease4Ptr& lease4) = 0;

    virtual void updateLease6(const Lease6Ptr& lease6) = 0;

    virtual bool deleteLease(const Lease4Ptr& lease) = 0;

    virtual bool deleteLease(const Lease6Ptr& lease) = 0;

    virtual uint64_t deleteExpiredReclaimedLeases4(const uint32_t secs) = 0;

    virtual uint64_t deleteExpiredReclaimedLeases6(const uint32_t secs) = 0;

    void recountLeaseStats4();

    virtual LeaseStatsQueryPtr startLeaseStatsQuery4();

    virtual LeaseStatsQueryPtr startPoolLeaseStatsQuery4();

    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery4(const SubnetID& subnet_id);

    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery4(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id);

    void recountLeaseStats6();

    virtual LeaseStatsQueryPtr startLeaseStatsQuery6();

    virtual LeaseStatsQueryPtr startPoolLeaseStatsQuery6();

    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery6(const SubnetID& subnet_id);

    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery6(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id);

    virtual size_t wipeLeases4(const SubnetID& subnet_id) = 0;

    virtual size_t wipeLeases6(const SubnetID& subnet_id) = 0;

    virtual std::string checkLimits4(isc::data::ConstElementPtr const& user_context) const = 0;

    virtual std::string checkLimits6(isc::data::ConstElementPtr const& user_context) const = 0;

    virtual std::string getType() const = 0;

    virtual std::string getName() const = 0;

    virtual std::string getDescription() const = 0;

    virtual VersionPair getVersion(const std::string& timer_name = std::string()) const = 0;

    virtual void commit() = 0;

    virtual void rollback() = 0;
 
    // -- The following are memfile only, but defined in the base LeaseMgr for convenience. --

    virtual size_t getClassLeaseCount(const ClientClass& client_class,
                                      const Lease::Type& ltype = Lease::TYPE_V4) const = 0;

    virtual void recountClassLeases4() = 0;

    virtual void recountClassLeases6() = 0;

    virtual void clearClassLeaseCounts() = 0;


    static bool
    upgradeLease4ExtendedInfo(const Lease4Ptr& lease,
                              CfgConsistency::ExtendedInfoSanity check =
                              CfgConsistency::EXTENDED_INFO_CHECK_FIX);

    static bool
    upgradeLease6ExtendedInfo(const Lease6Ptr& lease,
                              CfgConsistency::ExtendedInfoSanity check =
                              CfgConsistency::EXTENDED_INFO_CHECK_FIX);

    static void extractLease4ExtendedInfo(const Lease4Ptr& lease,
                                          bool ignore_errors = true);

    virtual Lease4Collection
    getLeases4ByRelayId(const OptionBuffer& relay_id,
                        const asiolink::IOAddress& lower_bound_address,
                        const LeasePageSize& page_size,
                        const time_t& qry_start_time = 0,
                        const time_t& qry_end_time = 0) = 0;

    virtual Lease4Collection
    getLeases4ByRemoteId(const OptionBuffer& remote_id,
                         const asiolink::IOAddress& lower_bound_address,
                         const LeasePageSize& page_size,
                         const time_t& qry_start_time = 0,
                         const time_t& qry_end_time = 0) = 0;

    virtual Lease6Collection
    getLeases6ByRelayId(const DUID& relay_id,
                        const asiolink::IOAddress& lower_bound_address,
                        const LeasePageSize& page_size) = 0;

    virtual Lease6Collection
    getLeases6ByRemoteId(const OptionBuffer& remote_id,
                         const asiolink::IOAddress& lower_bound_address,
                         const LeasePageSize& page_size) = 0;

    virtual void writeLeases4(const std::string& filename) = 0;

    virtual void writeLeases6(const std::string& filename) = 0;

    virtual size_t upgradeExtendedInfo4(const LeasePageSize& page_size) = 0;

    bool getExtendedInfoTablesEnabled() const {
        return (extended_info_tables_enabled_);
    }

    void setExtendedInfoTablesEnabled(const bool enabled) {
        extended_info_tables_enabled_ = enabled;
    }

    virtual size_t upgradeExtendedInfo6(const LeasePageSize& page_size) = 0;

    virtual void wipeExtendedInfoTables6() = 0;

    virtual size_t byRelayId6size() const;

    virtual size_t byRemoteId6size() const;

    virtual data::ElementPtr getStatus() const;

    virtual isc::data::ConstElementPtr lfcStartHandler();

    virtual bool sflqCreateFlqPool4(asiolink::IOAddress start_address,
                                    asiolink::IOAddress end_address,
                                    SubnetID subnet_id, bool recreate = false);

    virtual asiolink::IOAddress sflqPickFreeLease4(asiolink::IOAddress start_address,
                                                   asiolink::IOAddress end_address);

    virtual bool sflqCreateFlqPool6(asiolink::IOAddress start_address,
                                    asiolink::IOAddress end_address,
                                    Lease::Type lease_type, uint8_t delegated_len,
                                    SubnetID subnet_id, bool recreate = false);

    virtual asiolink::IOAddress sflqPickFreeLease6(asiolink::IOAddress start_address,
                                                   asiolink::IOAddress end_address);

    virtual SflqPoolInfoCollectionPtr sflqPool4GetAll();

    virtual SflqPoolInfoCollectionPtr sflqPool4Get(SubnetID subnet_id);

    virtual SflqPoolInfoCollectionPtr sflqPool4Get(asiolink::IOAddress start_address,
                                                   asiolink::IOAddress end_address);

    virtual bool sflqPool4Del(asiolink::IOAddress start_address,
                              asiolink::IOAddress end_address,
                              bool force = false);

    virtual SflqPoolInfoCollectionPtr sflqPool6GetAll();

    virtual SflqPoolInfoCollectionPtr sflqPool6Get(SubnetID subnet_id);

    virtual SflqPoolInfoCollectionPtr sflqPool6Get(asiolink::IOAddress start_address,
                                                   asiolink::IOAddress end_address);

    virtual bool sflqPool6Del(asiolink::IOAddress start_address,
                              asiolink::IOAddress end_address,
                              bool force = false);

    static bool useSharedFlqStatement(Lease4Ptr lease);

    static bool useSharedFlqStatement(Lease6Ptr lease);

    static void updateStatsOnAdd(const Lease4Ptr& lease);

    static void updateStatsOnAdd(const Lease6Ptr& lease);

    static void updateStatsOnUpdate(const Lease4Ptr& existing,
                                    const Lease4Ptr& lease);

    static void updateStatsOnUpdate(const Lease6Ptr& existing,
                                    const Lease6Ptr& lease);

    static void updateStatsOnDelete(const Lease4Ptr& lease);

    static void updateStatsOnDelete(const Lease6Ptr& lease);

    static void bumpStat(const std::string& stat, SubnetID& subnet_id,
                         PoolPtr pool, int value);

    static void bumpStatPrefix(const std::string& stat, SubnetID&
                               subnet_id, PoolPtr pool, int value);
protected:


    void setExtendedInfoTablesEnabled(const db::DatabaseConnection::ParameterMap& parameters);

    virtual bool addExtendedInfo6(const Lease6Ptr& lease);

    virtual void deleteExtendedInfo6(const isc::asiolink::IOAddress& addr) = 0;

    virtual void addRelayId6(const isc::asiolink::IOAddress& lease_addr,
                             const std::vector<uint8_t>& relay_id) = 0;

    virtual void addRemoteId6(const isc::asiolink::IOAddress& lease_addr,
                              const std::vector<uint8_t>& remote_id) = 0;
 
private:

    bool extended_info_tables_enabled_;
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif // LEASE_MGR_H