lease.h

Go to the documentation of this file.

// Copyright (C) 2013-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 LEASE_H
#define LEASE_H
 
#include <asiolink/io_address.h>
#include <dhcp/duid.h>
#include <dhcp/option.h>
#include <dhcp/hwaddr.h>
#include <dhcpsrv/subnet_id.h>
#include <cc/user_context.h>
#include <cc/cfg_to_element.h>
#include <util/dhcp_space.h>
 
namespace isc {
namespace dhcp {
 
struct Lease;
 
typedef boost::shared_ptr<Lease> LeasePtr;
 
struct Lease : public isc::data::UserContext, public isc::data::CfgToElement {
 
    static const uint32_t INFINITY_LFT = 0xffffffff;
 
    static std::string lifetimeToText(uint32_t lifetime);
 
    typedef enum {
        TYPE_NA = 0, 
        TYPE_TA = 1, 
        TYPE_PD = 2, 
        TYPE_V4 = 3  
    } Type;
 
    static std::string typeToText(Type type);
 
    static Type textToType(const std::string& text);
 
 
    static const uint32_t STATE_DEFAULT;
 
    static const uint32_t STATE_DECLINED;
 
    static const uint32_t STATE_EXPIRED_RECLAIMED;
 
    static std::string basicStatesToText(const uint32_t state);
 
    Lease(const isc::asiolink::IOAddress& addr,
          uint32_t valid_lft, SubnetID subnet_id, time_t cltt,
          const bool fqdn_fwd, const bool fqdn_rev,
          const std::string& hostname,
          const HWAddrPtr& hwaddr);
 
    virtual ~Lease() {}
 
    virtual Lease::Type getType() const = 0;
 
    isc::asiolink::IOAddress addr_;
 
    uint32_t valid_lft_;
 
    uint32_t current_valid_lft_;
 
    uint32_t reuseable_valid_lft_;
 
    time_t cltt_;
 
    time_t current_cltt_;
 
    SubnetID subnet_id_;
 
    uint32_t pool_id_;
 
    std::string hostname_;
 
    bool fqdn_fwd_;
 
    bool fqdn_rev_;
 
    HWAddrPtr hwaddr_;
 
    uint32_t state_;
 
    virtual std::string toText() const = 0;
 
    bool expired() const;
 
    bool stateExpiredReclaimed() const;
 
    bool stateDeclined() const;
 
    bool hasIdenticalFqdn(const Lease& other) const;
 
    const std::vector<uint8_t>& getHWAddrVector() const;
 
    int64_t getExpirationTime() const;
 
    virtual void decline(uint32_t probation_period) = 0;
 
    using isc::data::CfgToElement::toElement;
 
    static void syncCurrentExpirationTime(const Lease& from, Lease& to);
 
    void updateCurrentExpirationTime();
 
protected:
 
    static void fromElementCommon(const LeasePtr& lease,
                                  const data::ConstElementPtr& element);
 
};
 
struct Lease4;
 
typedef boost::shared_ptr<Lease4> Lease4Ptr;
 
struct Lease4 : public Lease {
 
    ClientIdPtr client_id_;
 
    Lease4(const isc::asiolink::IOAddress& addr, const HWAddrPtr& hwaddr,
           const uint8_t* clientid, size_t clientid_len, uint32_t valid_lft,
           time_t cltt, uint32_t subnet_id,
           const bool fqdn_fwd = false, const bool fqdn_rev = false,
           const std::string& hostname = "")
        : Lease(addr, valid_lft, subnet_id, cltt, fqdn_fwd, fqdn_rev,
                hostname, hwaddr) {
        if (clientid_len) {
            client_id_.reset(new ClientId(clientid, clientid_len));
        }
    }
 
    Lease4(const isc::asiolink::IOAddress& address,
           const HWAddrPtr& hw_address,
           const ClientIdPtr& client_id,
           const uint32_t valid_lifetime,
           const time_t cltt,
           const SubnetID subnet_id,
           const bool fqdn_fwd = false,
           const bool fqdn_rev = false,
           const std::string& hostname = "");
 
 
    Lease4();
 
    virtual Lease::Type getType() const {
        return (Lease::TYPE_V4);
    }
 
    static std::string statesToText(const uint32_t state);
 
    const std::vector<uint8_t>& getClientIdVector() const;
 
    bool belongsToClient(const HWAddrPtr& hw_address,
                         const ClientIdPtr& client_id) const;
 
    bool operator==(const Lease4& other) const;
 
    bool operator!=(const Lease4& other) const {
        return (!operator==(other));
    }
 
    virtual std::string toText() const;
 
    void decline(uint32_t probation_period);
 
    virtual isc::data::ElementPtr toElement() const;
 
    static Lease4Ptr fromElement(const data::ConstElementPtr& element);
 
 
    std::vector<uint8_t> remote_id_;
 
    std::vector<uint8_t> relay_id_;
};
 
typedef std::vector<Lease4Ptr> Lease4Collection;
 
typedef boost::shared_ptr<Lease4Collection> Lease4CollectionPtr;
 
struct Lease6;
 
typedef boost::shared_ptr<Lease6> Lease6Ptr;
 
struct Lease6 : public Lease {
 
    Lease::Type type_;
 
    uint8_t prefixlen_;
 
    uint32_t iaid_;
 
    DuidPtr duid_;
 
    uint32_t preferred_lft_;
 
    uint32_t reuseable_preferred_lft_;
 
    typedef enum {
        ACTION_IGNORE, 
        ACTION_DELETE, 
        ACTION_UPDATE  
    } ExtendedInfoAction;
 
    ExtendedInfoAction extended_info_action_;
 
 
    Lease6(Lease::Type type, const isc::asiolink::IOAddress& addr, DuidPtr duid,
           uint32_t iaid, uint32_t preferred, uint32_t valid,
           SubnetID subnet_id, const HWAddrPtr& hwaddr = HWAddrPtr(),
           uint8_t prefixlen = 128);
 
    Lease6(Lease::Type type, const isc::asiolink::IOAddress& addr, DuidPtr duid,
           uint32_t iaid, uint32_t preferred, uint32_t valid,
           SubnetID subnet_id, const bool fqdn_fwd,
           const bool fqdn_rev, const std::string& hostname,
           const HWAddrPtr& hwaddr = HWAddrPtr(), uint8_t prefixlen = 128);
 
    Lease6();
 
    virtual Lease::Type getType() const {
        return (type_);
    }
 
    static std::string statesToText(const uint32_t state);
 
    const std::vector<uint8_t>& getDuidVector() const;
 
    void decline(uint32_t probation_period);
 
    bool operator==(const Lease6& other) const;
 
    bool operator!=(const Lease6& other) const {
        return (!operator==(other));
    }
 
    virtual std::string toText() const;
 
    virtual isc::data::ElementPtr toElement() const;
 
    static Lease6Ptr fromElement(const data::ConstElementPtr& element);
};
 
typedef boost::shared_ptr<const Lease6> ConstLease6Ptr;
 
typedef std::vector<Lease6Ptr> Lease6Collection;
 
typedef boost::shared_ptr<Lease6Collection> Lease6CollectionPtr;
 
std::ostream&
operator<<(std::ostream& os, const Lease& lease);
 
namespace {
 
template <isc::util::DhcpSpace D>
struct AdapterLease {};
 
template <>
struct AdapterLease<isc::util::DHCPv4> {
    using type = Lease4;
};
 
template <>
struct AdapterLease<isc::util::DHCPv6> {
    using type = Lease6;
};
 
}  // namespace
 
template <isc::util::DhcpSpace D>
using LeaseT = typename AdapterLease<D>::type;
 
template <isc::util::DhcpSpace D>
using LeaseTPtr = boost::shared_ptr<LeaseT<D>>;
 
}  // end of isc::dhcp namespace
}  // end of isc namespace
 
#endif // LEASE_H