lease.h

Go to the documentation of this file.

// Copyright (C) 2013-2022 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_;

    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() : Lease(0, 0, 0, 0, false, false, "", HWAddrPtr())
    {
    }

    Lease4(const Lease4& other);

    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;

    Lease4& operator=(const Lease4& other);

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

};

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


    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