subnet.h

Go to the documentation of this file.

// Copyright (C) 2012-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 SUBNET_H
#define SUBNET_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <cc/user_context.h>
#include <dhcp/option_space_container.h>
#include <dhcpsrv/allocator.h>
#include <dhcpsrv/allocation_state.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/network.h>
#include <dhcpsrv/pool.h>
#include <dhcpsrv/subnet_id.h>
#include <util/bigints.h>
#include <util/dhcp_space.h>
#include <util/triplet.h>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/random_access_index.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/pointer_cast.hpp>
#include <boost/shared_ptr.hpp>
 
#include <cstdint>
#include <map>
#include <utility>
 
namespace isc {
namespace dhcp {
 
class Subnet : public virtual Network {
public:
 
    bool inRange(const isc::asiolink::IOAddress& addr) const;
 
    bool inPool(Lease::Type type, const isc::asiolink::IOAddress& addr) const;
 
    bool inPool(Lease::Type type,
                const isc::asiolink::IOAddress& addr,
                const ClientClasses& client_classes) const;
 
    SubnetID getID() const {
        return (id_);
    }
 
    std::pair<isc::asiolink::IOAddress, uint8_t> get() const {
        return (std::make_pair(prefix_, prefix_len_));
    }
 
    void addPool(const PoolPtr& pool);
 
    void delPools(Lease::Type type);
 
    const PoolPtr getPool(Lease::Type type, const isc::asiolink::IOAddress& addr,
                          bool anypool = true) const;
 
    const PoolPtr getPool(Lease::Type type,
                          const ClientClasses& client_classes,
                          const isc::asiolink::IOAddress& addr) const;
 
    PoolPtr getAnyPool(Lease::Type type) {
        return (getPool(type, default_pool()));
    }
 
    virtual isc::asiolink::IOAddress default_pool() const = 0;
 
    const PoolCollection& getPools(Lease::Type type) const;
 
    isc::util::uint128_t getPoolCapacity(Lease::Type type) const;
 
    isc::util::uint128_t getPoolCapacity(Lease::Type type,
                                         const ClientClasses& client_classes) const;
 
    isc::util::uint128_t getPoolCapacity(Lease::Type type,
                                         const ClientClasses& client_classes,
                                         Allocator::PrefixLenMatchType prefix_length_match,
                                         uint8_t hint_prefix_length) const;
 
    virtual std::string toText() const;
 
    static void resetSubnetID() {
        static_id_ = 1;
    }
 
    template<typename SharedNetworkPtrType>
    void getSharedNetwork(SharedNetworkPtrType& shared_network) const {
        shared_network = boost::dynamic_pointer_cast<
            typename SharedNetworkPtrType::element_type>(parent_network_.lock());
    }
 
    void setSharedNetwork(const NetworkPtr& shared_network) {
        parent_network_ = shared_network;
    }
 
    std::string getSharedNetworkName() const {
        return (shared_network_name_);
    }
 
    void setSharedNetworkName(const std::string& shared_network_name) {
        shared_network_name_ = shared_network_name;
    }
 
    PoolCollection& getPoolsWritable(Lease::Type type);
 
    AllocatorPtr getAllocator(Lease::Type type) const;
 
    void setAllocator(Lease::Type type, const AllocatorPtr& allocator);
 
    SubnetAllocationStatePtr getAllocationState(Lease::Type type) const;
 
    void setAllocationState(Lease::Type type, const SubnetAllocationStatePtr& allocation_state);
 
    virtual void createAllocators() = 0;
 
    void initAllocatorsAfterConfigure();
 
protected:
 
    //
    Subnet(const isc::asiolink::IOAddress& prefix, uint8_t len,
           const SubnetID id);
 
    virtual ~Subnet() { };
 
    static SubnetID static_id_;
 
    static SubnetID generateNextID() {
        if (static_id_ == SUBNET_ID_MAX) {
            resetSubnetID();
        }
 
        return (static_id_++);
    }
 
    virtual void checkType(Lease::Type type) const = 0;
 
    isc::util::uint128_t sumPoolCapacity(const PoolCollection& pools) const;
 
    isc::util::uint128_t sumPoolCapacity(const PoolCollection& pools,
                                         const ClientClasses& client_classes) const;
 
    isc::util::uint128_t sumPoolCapacity(const PoolCollection& pools,
                                         const ClientClasses& client_classes,
                                         Allocator::PrefixLenMatchType prefix_length_match,
                                         uint8_t hint_prefix_length) const;
 
    bool poolOverlaps(const Lease::Type& pool_type, const PoolPtr& pool) const;
 
    virtual data::ElementPtr toElement() const;
 
    virtual std::string getLabel() const {
        std::stringstream ss;
        ss << "subnet-id " << id_;
        return (ss.str());
    }
 
    static std::pair<asiolink::IOAddress, uint8_t>
    parsePrefixCommon(const std::string& prefix);
 
    SubnetID id_;
 
    PoolCollection pools_;
 
    PoolCollection pools_ta_;
 
    PoolCollection pools_pd_;
 
    isc::asiolink::IOAddress prefix_;
 
    uint8_t prefix_len_;
 
    std::string shared_network_name_;
 
    std::map<Lease::Type, AllocatorPtr> allocators_;
 
    std::map<Lease::Type, SubnetAllocationStatePtr> allocation_states_;
};
 
typedef boost::shared_ptr<Subnet> SubnetPtr;
 
 
class Subnet4;
 
typedef boost::shared_ptr<const Subnet4> ConstSubnet4Ptr;
 
typedef boost::shared_ptr<Subnet4> Subnet4Ptr;
 
class Subnet4 : public Subnet, public Network4, public boost::enable_shared_from_this<Subnet4> {
public:
 
    Subnet4(const isc::asiolink::IOAddress& prefix, uint8_t length,
            const util::Triplet<uint32_t>& t1,
            const util::Triplet<uint32_t>& t2,
            const util::Triplet<uint32_t>& valid_lifetime,
            const SubnetID id = 0);
 
    static Subnet4Ptr
    create(const isc::asiolink::IOAddress& prefix, uint8_t length,
           const util::Triplet<uint32_t>& t1,
           const util::Triplet<uint32_t>& t2,
           const util::Triplet<uint32_t>& valid_lifetime,
           const SubnetID id = 0);
 
    Subnet4Ptr getNextSubnet(const Subnet4Ptr& first_subnet) const;
 
    Subnet4Ptr getNextSubnet(const Subnet4Ptr& first_subnet,
                             const ClientClasses& client_classes) const;
 
    virtual bool
    clientSupported(const isc::dhcp::ClientClasses& client_classes) const;
 
    Cfg4o6& get4o6() {
        return (dhcp4o6_);
    }
 
    const Cfg4o6& get4o6() const {
        return (dhcp4o6_);
    }
 
    virtual data::ElementPtr toElement() const;
 
    virtual void createAllocators();
 
    static std::pair<asiolink::IOAddress, uint8_t>
    parsePrefix(const std::string& prefix);
 
private:
 
    Subnet4(const Subnet4&) = delete;
 
    Subnet4& operator=(const Subnet4&) = delete;
 
    virtual isc::asiolink::IOAddress default_pool() const {
        return (isc::asiolink::IOAddress("0.0.0.0"));
    }
 
    virtual void checkType(Lease::Type type) const;
 
    Cfg4o6 dhcp4o6_;
};
 
class Subnet6;
 
typedef boost::shared_ptr<const Subnet6> ConstSubnet6Ptr;
 
typedef boost::shared_ptr<Subnet6> Subnet6Ptr;
 
class Subnet6 : public Subnet, public Network6, public boost::enable_shared_from_this<Subnet6> {
public:
 
    Subnet6(const isc::asiolink::IOAddress& prefix, uint8_t length,
            const util::Triplet<uint32_t>& t1,
            const util::Triplet<uint32_t>& t2,
            const util::Triplet<uint32_t>& preferred_lifetime,
            const util::Triplet<uint32_t>& valid_lifetime,
            const SubnetID id = 0);
 
    static Subnet6Ptr
    create(const isc::asiolink::IOAddress& prefix, uint8_t length,
           const util::Triplet<uint32_t>& t1,
           const util::Triplet<uint32_t>& t2,
           const util::Triplet<uint32_t>& preferred_lifetime,
           const util::Triplet<uint32_t>& valid_lifetime,
           const SubnetID id = 0);
 
    Subnet6Ptr getNextSubnet(const Subnet6Ptr& first_subnet) const;
 
    Subnet6Ptr getNextSubnet(const Subnet6Ptr& first_subnet,
                             const ClientClasses& client_classes) const;
 
    virtual bool
    clientSupported(const isc::dhcp::ClientClasses& client_classes) const;
 
    virtual void createAllocators();
 
    virtual data::ElementPtr toElement() const;
 
    static std::pair<asiolink::IOAddress, uint8_t>
    parsePrefix(const std::string& prefix);
 
private:
 
    Subnet6(const Subnet6&) = delete;
 
    Subnet6& operator=(const Subnet6&) = delete;
 
    virtual isc::asiolink::IOAddress default_pool() const {
        return (isc::asiolink::IOAddress("::"));
    }
 
    virtual void checkType(Lease::Type type) const;
 
};
 
 
 
struct SubnetSubnetIdIndexTag { };
 
struct SubnetPrefixIndexTag { };
 
struct SubnetServerIdIndexTag { };
 
struct SubnetModificationTimeIndexTag { };
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the subnets.
    Subnet4Ptr,
    // The following holds all indexes.
    boost::multi_index::indexed_by<
        // First index allows for searching using subnet identifier.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetSubnetIdIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, SubnetID, &Subnet::getID>
        >,
        // Second index allows for searching using an output from toText function.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetPrefixIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, std::string, &Subnet::toText>
        >
    >
> Subnet4SimpleCollection;
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the subnets.
    Subnet4Ptr,
    // The following holds all indexes.
    boost::multi_index::indexed_by<
        // First index allows for searching using subnet identifier.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetSubnetIdIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, SubnetID, &Subnet::getID>
        >,
        // Second index allows for searching using an output from toText function.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetPrefixIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, std::string, &Subnet::toText>
        >,
 
        // Third index allows for searching using an output from getServerId.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SubnetServerIdIndexTag>,
            boost::multi_index::const_mem_fun<Network4, asiolink::IOAddress,
                                              &Network4::getServerId>
        >,
 
        // Forth index allows for searching using subnet modification time.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SubnetModificationTimeIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement,
                                              boost::posix_time::ptime,
                                              &data::BaseStampedElement::getModificationTime>
        >
    >
> Subnet4Collection;
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the subnets.
    Subnet6Ptr,
    // The following holds all indexes.
    boost::multi_index::indexed_by<
        // First index allows for searching using subnet identifier.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetSubnetIdIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, SubnetID, &Subnet::getID>
        >,
        // Second index allows for searching using an output from toText function.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetPrefixIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, std::string, &Subnet::toText>
        >
    >
> Subnet6SimpleCollection;
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the subnets.
    Subnet6Ptr,
    // The following holds all indexes.
    boost::multi_index::indexed_by<
        // First index allows for searching using subnet identifier.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetSubnetIdIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, SubnetID, &Subnet::getID>
        >,
        // Second index allows for searching using an output from toText function.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SubnetPrefixIndexTag>,
            boost::multi_index::const_mem_fun<Subnet, std::string, &Subnet::toText>
        >,
        // Third index allows for searching using subnet modification time.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SubnetModificationTimeIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement,
                                              boost::posix_time::ptime,
                                              &data::BaseStampedElement::getModificationTime>
        >
    >
> Subnet6Collection;
 
template<typename ReturnPtrType, typename CollectionType>
class SubnetFetcher {
public:
 
    static ReturnPtrType get(const CollectionType& collection,
                             const SubnetID& subnet_id) {
        auto& index = collection.template get<SubnetSubnetIdIndexTag>();
        auto s = index.find(subnet_id);
        if (s != index.end()) {
            return (*s);
        }
        // No subnet found. Return null pointer.
        return (ReturnPtrType());
    }
};
 
using SubnetFetcher4 = SubnetFetcher<Subnet4Ptr, Subnet4Collection>;
 
using SubnetFetcher6 = SubnetFetcher<Subnet6Ptr, Subnet6Collection>;
 
namespace {
 
template <isc::util::DhcpSpace D>
struct AdapterSubnet {};
 
template <>
struct AdapterSubnet<isc::util::DHCPv4> {
    using type = Subnet4;
};
 
template <>
struct AdapterSubnet<isc::util::DHCPv6> {
    using type = Subnet6;
};
 
}  // namespace
 
template <isc::util::DhcpSpace D>
using SubnetT = typename AdapterSubnet<D>::type;
 
template <isc::util::DhcpSpace D>
using SubnetTPtr = boost::shared_ptr<SubnetT<D>>;
 
} // end of isc::dhcp namespace
} // end of isc namespace
 
#endif // SUBNET_H