Adding upstream version 2.4.1.upstream/2.4.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 952 insertions, 0 deletions

diff --git a/src/lib/dhcpsrv/subnet.cc b/src/lib/dhcpsrv/subnet.cc
new file mode 100644
index 0000000..2e480d4
--- /dev/null
+++ b/src/lib/dhcpsrv/subnet.cc
@@ -0,0 +1,952 @@
+// 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/.
+
+#include <config.h>
+
+#include <asiolink/io_address.h>
+#include <asiolink/addr_utilities.h>
+#include <dhcp/option_space.h>
+#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/flq_allocation_state.h>
+#include <dhcpsrv/flq_allocator.h>
+#include <dhcpsrv/iterative_allocation_state.h>
+#include <dhcpsrv/iterative_allocator.h>
+#include <dhcpsrv/random_allocation_state.h>
+#include <dhcpsrv/random_allocator.h>
+#include <dhcpsrv/shared_network.h>
+#include <dhcpsrv/subnet.h>
+#include <util/multi_threading_mgr.h>
+
+#include <boost/lexical_cast.hpp>
+#include <boost/make_shared.hpp>
+
+#include <algorithm>
+#include <limits>
+#include <sstream>
+
+using namespace isc::asiolink;
+using namespace isc::data;
+using namespace isc::dhcp;
+using namespace isc::util;
+
+using namespace std;
+
+namespace {
+
+/// @brief Function used in calls to std::upper_bound to check
+/// if the specified prefix is lower than the first address a pool.
+///
+/// @return true if prefix is lower than the first address in the pool.
+bool
+prefixLessThanFirstAddress(const IOAddress& prefix,
+                           const PoolPtr& pool) {
+    return (prefix < pool->getFirstAddress());
+}
+
+/// @brief Function used in calls to std::sort to compare first
+/// prefixes of the two pools.
+///
+/// @param pool1 First pool.
+/// @param pool2 Second pool.
+///
+/// @return true if first prefix of the first pool is smaller than
+/// the first address of the second pool.
+bool
+comparePoolFirstAddress(const PoolPtr& pool1,
+                        const PoolPtr& pool2) {
+    return (pool1->getFirstAddress() < pool2->getFirstAddress());
+}
+
+}
+
+namespace isc {
+namespace dhcp {
+
+// This is an initial value of subnet-id. See comments in subnet.h for details.
+SubnetID Subnet::static_id_ = 1;
+
+Subnet::Subnet(const isc::asiolink::IOAddress& prefix, uint8_t len,
+               const SubnetID id)
+    : id_(id == 0 ? generateNextID() : id), prefix_(prefix),
+      prefix_len_(len),
+      shared_network_name_() {
+    if ((id == 0) && (id_ == 1)) {
+        // Emit a warning on the first auto-numbered subnet.
+        LOG_WARN(dhcpsrv_logger, DHCPSRV_CONFIGURED_SUBNET_WITHOUT_ID)
+            .arg(toText());
+    }
+    if ((prefix.isV6() && len > 128) ||
+        (prefix.isV4() && len > 32)) {
+        isc_throw(BadValue,
+                  "Invalid prefix length specified for subnet: " << len);
+    }
+}
+
+bool
+Subnet::inRange(const isc::asiolink::IOAddress& addr) const {
+    IOAddress first = firstAddrInPrefix(prefix_, prefix_len_);
+    IOAddress last = lastAddrInPrefix(prefix_, prefix_len_);
+
+    return ((first <= addr) && (addr <= last));
+}
+
+std::string
+Subnet::toText() const {
+    std::stringstream tmp;
+    tmp << prefix_ << "/" << static_cast<unsigned int>(prefix_len_);
+    return (tmp.str());
+}
+
+uint128_t
+Subnet::getPoolCapacity(Lease::Type type) const {
+    switch (type) {
+    case Lease::TYPE_V4:
+    case Lease::TYPE_NA:
+        return sumPoolCapacity(pools_);
+    case Lease::TYPE_TA:
+        return sumPoolCapacity(pools_ta_);
+    case Lease::TYPE_PD:
+        return sumPoolCapacity(pools_pd_);
+    default:
+        isc_throw(BadValue, "Unsupported pool type: "
+                  << static_cast<int>(type));
+    }
+}
+
+uint128_t
+Subnet::getPoolCapacity(Lease::Type type,
+                        const ClientClasses& client_classes) const {
+    switch (type) {
+    case Lease::TYPE_V4:
+    case Lease::TYPE_NA:
+        return sumPoolCapacity(pools_, client_classes);
+    case Lease::TYPE_TA:
+        return sumPoolCapacity(pools_ta_, client_classes);
+    case Lease::TYPE_PD:
+        return sumPoolCapacity(pools_pd_, client_classes);
+    default:
+        isc_throw(BadValue, "Unsupported pool type: "
+                  << static_cast<int>(type));
+    }
+}
+
+uint128_t
+Subnet::getPoolCapacity(Lease::Type type,
+                        const ClientClasses& client_classes,
+                        Allocator::PrefixLenMatchType prefix_length_match,
+                        uint8_t hint_prefix_length) const {
+    switch (type) {
+    case Lease::TYPE_V4:
+    case Lease::TYPE_NA:
+        return sumPoolCapacity(pools_, client_classes);
+    case Lease::TYPE_TA:
+        return sumPoolCapacity(pools_ta_, client_classes);
+    case Lease::TYPE_PD:
+        return sumPoolCapacity(pools_pd_, client_classes, prefix_length_match,
+                               hint_prefix_length);
+    default:
+        isc_throw(BadValue, "Unsupported pool type: "
+                  << static_cast<int>(type));
+    }
+}
+
+uint128_t
+Subnet::sumPoolCapacity(const PoolCollection& pools) const {
+    uint128_t sum(0);
+    for (auto const& p : pools) {
+        uint128_t const c(p->getCapacity());
+
+        // Check if we can add it. If sum + c > UINT128_MAX, then we would have
+        // overflown if we tried to add it.
+        if (c > numeric_limits<uint128_t>::max() - sum) {
+            return (numeric_limits<uint128_t>::max());
+        }
+
+        sum += c;
+    }
+
+    return (sum);
+}
+
+uint128_t
+Subnet::sumPoolCapacity(const PoolCollection& pools,
+                        const ClientClasses& client_classes) const {
+    uint128_t sum(0);
+    for (auto const& p : pools) {
+        if (!p->clientSupported(client_classes)) {
+            continue;
+        }
+
+        uint128_t const c(p->getCapacity());
+
+        // Check if we can add it. If sum + c > UINT128_MAX, then we would have
+        // overflown if we tried to add it.
+        if (c > numeric_limits<uint128_t>::max() - sum) {
+            return (numeric_limits<uint128_t>::max());
+        }
+
+        sum += c;
+    }
+
+    return (sum);
+}
+
+uint128_t
+Subnet::sumPoolCapacity(const PoolCollection& pools,
+                        const ClientClasses& client_classes,
+                        Allocator::PrefixLenMatchType prefix_length_match,
+                        uint8_t hint_prefix_length) const {
+    uint128_t sum(0);
+    for (auto const& p : pools) {
+        if (!p->clientSupported(client_classes)) {
+            continue;
+        }
+
+        if (!Allocator::isValidPrefixPool(prefix_length_match, p,
+                                          hint_prefix_length)) {
+            continue;
+        }
+
+        uint128_t const c(p->getCapacity());
+
+        // Check if we can add it. If sum + c > UINT128_MAX, then we would have
+        // overflown if we tried to add it.
+        if (c > numeric_limits<uint128_t>::max() - sum) {
+            return (numeric_limits<uint128_t>::max());
+        }
+
+        sum += c;
+    }
+
+    return (sum);
+}
+
+std::pair<IOAddress, uint8_t>
+Subnet::parsePrefixCommon(const std::string& prefix) {
+    auto pos = prefix.find('/');
+    if ((pos == std::string::npos) ||
+        (pos == prefix.size() - 1) ||
+        (pos == 0)) {
+        isc_throw(BadValue, "unable to parse invalid prefix " << prefix);
+    }
+
+    try {
+        IOAddress address(prefix.substr(0, pos));
+        int length = boost::lexical_cast<int>(prefix.substr(pos + 1));
+        return (std::make_pair(address, static_cast<int>(length)));
+
+    } catch (...) {
+        isc_throw(BadValue, "unable to parse invalid prefix " << prefix);
+    }
+}
+
+
+void Subnet4::checkType(Lease::Type type) const {
+    if (type != Lease::TYPE_V4) {
+        isc_throw(BadValue, "Only TYPE_V4 is allowed for Subnet4");
+    }
+}
+
+Subnet4::Subnet4(const IOAddress& prefix, uint8_t length,
+                 const Triplet<uint32_t>& t1,
+                 const Triplet<uint32_t>& t2,
+                 const Triplet<uint32_t>& valid_lifetime,
+                 const SubnetID id)
+    : Subnet(prefix, length, id), Network4() {
+    if (!prefix.isV4()) {
+        isc_throw(BadValue, "Non IPv4 prefix " << prefix.toText()
+                  << " specified in subnet4");
+    }
+    // Timers.
+    setT1(t1);
+    setT2(t2);
+    setValid(valid_lifetime);
+}
+
+Subnet4Ptr
+Subnet4::create(const IOAddress& prefix, uint8_t length,
+                const Triplet<uint32_t>& t1,
+                const Triplet<uint32_t>& t2,
+                const Triplet<uint32_t>& valid_lifetime,
+                const SubnetID id) {
+    Subnet4Ptr subnet = boost::make_shared<Subnet4>
+        (prefix, length, t1, t2, valid_lifetime, id);
+    subnet->setAllocator(Lease::TYPE_V4,
+                         boost::make_shared<IterativeAllocator>
+                         (Lease::TYPE_V4, subnet));
+    subnet->setAllocationState(Lease::TYPE_V4,
+                               SubnetIterativeAllocationState::create(subnet));
+
+    return (subnet);
+}
+
+Subnet4Ptr
+Subnet4::getNextSubnet(const Subnet4Ptr& first_subnet) const {
+    SharedNetwork4Ptr network;
+    getSharedNetwork(network);
+    if (network) {
+        return (network->getNextSubnet(first_subnet, getID()));
+    }
+
+    return (Subnet4Ptr());
+}
+
+Subnet4Ptr
+Subnet4::getNextSubnet(const Subnet4Ptr& first_subnet,
+                       const ClientClasses& client_classes) const {
+    SharedNetwork4Ptr network;
+    getSharedNetwork(network);
+    // We can only get next subnet if shared network has been defined for
+    // the current subnet.
+    if (network) {
+        Subnet4Ptr subnet;
+        do {
+            // Use subnet identifier of this subnet if this is the first
+            // time we're calling getNextSubnet. Otherwise, use the
+            // subnet id of the previously returned subnet.
+            SubnetID subnet_id = subnet ? subnet->getID() : getID();
+            subnet = network->getNextSubnet(first_subnet, subnet_id);
+            // If client classes match the subnet, return it. Otherwise,
+            // try another subnet.
+            if (subnet && subnet->clientSupported(client_classes)) {
+                return (subnet);
+            }
+        } while (subnet);
+    }
+
+    // No subnet found.
+    return (Subnet4Ptr());
+}
+
+
+bool
+Subnet4::clientSupported(const isc::dhcp::ClientClasses& client_classes) const {
+    NetworkPtr network;
+    getSharedNetwork(network);
+    if (network && !network->clientSupported(client_classes)) {
+        return (false);
+    }
+
+    return (Network4::clientSupported(client_classes));
+}
+
+const PoolCollection& Subnet::getPools(Lease::Type type) const {
+    // check if the type is valid (and throw if it isn't)
+    checkType(type);
+
+    switch (type) {
+    case Lease::TYPE_V4:
+    case Lease::TYPE_NA:
+        return (pools_);
+    case Lease::TYPE_TA:
+        return (pools_ta_);
+    case Lease::TYPE_PD:
+        return (pools_pd_);
+    default:
+        isc_throw(BadValue, "Unsupported pool type: "
+                  << static_cast<int>(type));
+    }
+}
+
+PoolCollection& Subnet::getPoolsWritable(Lease::Type type) {
+    // check if the type is valid (and throw if it isn't)
+    checkType(type);
+
+    switch (type) {
+    case Lease::TYPE_V4:
+    case Lease::TYPE_NA:
+        return (pools_);
+    case Lease::TYPE_TA:
+        return (pools_ta_);
+    case Lease::TYPE_PD:
+        return (pools_pd_);
+    default:
+        isc_throw(BadValue, "Invalid pool type specified: "
+                  << static_cast<int>(type));
+    }
+}
+
+AllocatorPtr
+Subnet::getAllocator(Lease::Type type) const {
+    auto alloc = allocators_.find(type);
+
+    if (alloc == allocators_.end()) {
+        isc_throw(BadValue, "no allocator initialized for pool type "
+                  << Lease::typeToText(type));
+    }
+    return (alloc->second);
+}
+
+void
+Subnet::setAllocator(Lease::Type type, const AllocatorPtr& allocator) {
+    allocators_[type] = allocator;
+}
+
+SubnetAllocationStatePtr
+Subnet::getAllocationState(Lease::Type type) const {
+    auto state = allocation_states_.find(type);
+
+    if (state == allocation_states_.end()) {
+        isc_throw(BadValue, "no allocation state initialized for pool type "
+                  << Lease::typeToText(type));
+    }
+    return (state->second);
+}
+
+void
+Subnet::setAllocationState(Lease::Type type, const SubnetAllocationStatePtr& allocation_state) {
+    allocation_states_[type] = allocation_state;
+}
+
+const PoolPtr Subnet::getPool(Lease::Type type, const isc::asiolink::IOAddress& hint,
+                              bool anypool /* true */) const {
+    // check if the type is valid (and throw if it isn't)
+    checkType(type);
+
+    const auto& pools = getPools(type);
+
+    PoolPtr candidate;
+
+    if (!pools.empty()) {
+        // Pools are sorted by their first prefixes. For example: 2001::,
+        // 2001::db8::, 3000:: etc. If our hint is 2001:db8:5:: we want to
+        // find the pool with the longest matching prefix, so: 2001:db8::,
+        // rather than 2001::. upper_bound returns the first pool with a prefix
+        // that is greater than 2001:db8:5::, i.e. 3000::. To find the longest
+        // matching prefix we use decrement operator to go back by one item.
+        // If returned iterator points to begin it means that prefixes in all
+        // pools are greater than out prefix, and thus there is no match.
+        auto ub =
+            std::upper_bound(pools.begin(), pools.end(), hint,
+                             prefixLessThanFirstAddress);
+
+        if (ub != pools.begin()) {
+            --ub;
+            if ((*ub)->inRange(hint)) {
+                candidate = *ub;
+            }
+        }
+
+        // If we don't find anything better, then let's just use the first pool
+        if (!candidate && anypool) {
+            candidate = *pools.begin();
+        }
+    }
+
+    // Return a pool or NULL if no match found.
+    return (candidate);
+}
+
+void
+Subnet::initAllocatorsAfterConfigure() {
+    for (auto allocator : allocators_) {
+        allocator.second->initAfterConfigure();
+    }
+}
+
+const PoolPtr Subnet::getPool(Lease::Type type,
+                              const ClientClasses& client_classes,
+                              const isc::asiolink::IOAddress& hint) const {
+    // check if the type is valid (and throw if it isn't)
+    checkType(type);
+
+    const auto& pools = getPools(type);
+
+    PoolPtr candidate;
+
+    if (!pools.empty()) {
+        auto ub =
+            std::upper_bound(pools.begin(), pools.end(), hint,
+                             prefixLessThanFirstAddress);
+
+        if (ub != pools.begin()) {
+            --ub;
+            if ((*ub)->inRange(hint) &&
+                (*ub)->clientSupported(client_classes)) {
+                candidate = *ub;
+            }
+        }
+    }
+
+    // Return a pool or NULL if no match found.
+    return (candidate);
+}
+
+void
+Subnet::addPool(const PoolPtr& pool) {
+    // check if the type is valid (and throw if it isn't)
+    checkType(pool->getType());
+
+    // Check that the pool is in range with a subnet only if this is
+    // not a pool of IPv6 prefixes. The IPv6 prefixes delegated for
+    // the particular subnet don't need to match the prefix of the
+    // subnet.
+    if (pool->getType() != Lease::TYPE_PD) {
+        if (!inRange(pool->getFirstAddress()) || !inRange(pool->getLastAddress())) {
+            isc_throw(BadValue, "a pool of type "
+                      << Lease::typeToText(pool->getType())
+                      << ", with the following address range: "
+                      << pool->getFirstAddress() << "-"
+                      << pool->getLastAddress() << " does not match"
+                      << " the prefix of a subnet: "
+                      << prefix_ << "/" << static_cast<int>(prefix_len_)
+                      << " to which it is being added");
+
+        }
+    }
+
+    bool overlaps = false;
+    if (pool->getType() == Lease::TYPE_V4) {
+        overlaps = poolOverlaps(Lease::TYPE_V4, pool);
+
+    } else {
+        overlaps =
+            poolOverlaps(Lease::TYPE_NA, pool) ||
+            poolOverlaps(Lease::TYPE_PD, pool) ||
+            poolOverlaps(Lease::TYPE_TA, pool);
+    }
+
+    if (overlaps) {
+        isc_throw(BadValue,"a pool of type "
+                  << Lease::typeToText(pool->getType())
+                  << ", with the following address range: "
+                  << pool->getFirstAddress() << "-"
+                  << pool->getLastAddress() << " overlaps with "
+                  "an existing pool in the subnet: "
+                  << prefix_ << "/" << static_cast<int>(prefix_len_)
+                  << " to which it is being added");
+    }
+
+    PoolCollection& pools_writable = getPoolsWritable(pool->getType());
+
+    // Add the pool to the appropriate pools collection
+    pools_writable.push_back(pool);
+
+    // Sort pools by first address.
+    std::sort(pools_writable.begin(), pools_writable.end(),
+              comparePoolFirstAddress);
+}
+
+void
+Subnet::delPools(Lease::Type type) {
+    getPoolsWritable(type).clear();
+}
+
+bool
+Subnet::inPool(Lease::Type type, const isc::asiolink::IOAddress& addr) const {
+
+    // Let's start with checking if it even belongs to that subnet.
+    if ((type != Lease::TYPE_PD) && !inRange(addr)) {
+        return (false);
+    }
+
+    const auto& pools = getPools(type);
+    for (const auto& pool : pools) {
+        if (pool->inRange(addr)) {
+            return (true);
+        }
+    }
+    // There's no pool that address belongs to
+    return (false);
+}
+
+bool
+Subnet::inPool(Lease::Type type,
+               const isc::asiolink::IOAddress& addr,
+               const ClientClasses& client_classes) const {
+
+    // Let's start with checking if it even belongs to that subnet.
+    if ((type != Lease::TYPE_PD) && !inRange(addr)) {
+        return (false);
+    }
+
+    const auto& pools = getPools(type);
+    for (const auto& pool : pools) {
+        if (!pool->clientSupported(client_classes)) {
+            continue;
+        }
+        if (pool->inRange(addr)) {
+            return (true);
+        }
+    }
+    // There's no pool that address belongs to
+    return (false);
+}
+
+bool
+Subnet::poolOverlaps(const Lease::Type& pool_type, const PoolPtr& pool) const {
+    const auto& pools = getPools(pool_type);
+
+    // If no pools, we don't overlap. Nothing to do.
+    if (pools.empty()) {
+        return (false);
+    }
+
+    // We're going to insert a new pool, likely between two existing pools.
+    // So we're going to end up with the following case:
+    // |<---- pool1 ---->|    |<-------- pool2 ------>|  |<-- pool3 -->|
+    // F1               L1    F2                     L2  F3           L3
+    // where pool1 and pool3 are existing pools, pool2 is a pool being
+    // inserted and "F"/"L" mark first and last address in the pools
+    // respectively. So the following conditions must be fulfilled:
+    // F2 > L1 and L2 < F3. Obviously, for any pool: F < L.
+
+    // Search for pool3. We use F2 and upper_bound to find the F3 (upper_bound
+    // returns first pool in the sorted container which first address is
+    // greater than F2). prefixLessThanPoolAddress with the first argument
+    // set to "true" is the custom comparison function for upper_bound, which
+    // compares F2 with the first addresses of the existing pools.
+    const auto pool3_it =
+        std::upper_bound(pools.begin(), pools.end(), pool->getFirstAddress(),
+                         prefixLessThanFirstAddress);
+
+    // The upper_bound function returns a first pool which first address is
+    // greater than the address F2. However, it is also possible that there is a
+    // pool which first address is equal to F2. Such pool is also in conflict
+    // with a new pool. If the returned value is pools.begin() it means that all
+    // pools have greater first address than F2, thus none of the pools can have
+    // first address equal to F2. Otherwise, we'd need to check them for
+    // equality. However any pool has first address <= last address, so checking
+    // that the new pool first address is greater than the pool before pool3
+    // last address is enough. We now have to find the pool1. This pool should
+    // be right before the pool3 if there is any pool before pool3.
+    if (pool3_it != pools.begin()) {
+        PoolPtr pool1 = *(pool3_it - 1);
+        // F2 must be greater than L1, otherwise pools will overlap.
+        if (pool->getFirstAddress() <= pool1->getLastAddress()) {
+            return (true);
+        }
+    }
+
+    // If returned value is unequal pools.end() it means that there is a pool3,
+    // with F3 > F2.
+    if (pool3_it != pools.end()) {
+        // Let's store the pointer to this pool.
+        PoolPtr pool3 = *pool3_it;
+        // F3 must be greater than L2, otherwise pools will overlap.
+        if (pool3->getFirstAddress() <= pool->getLastAddress()) {
+            return (true);
+        }
+    }
+
+    return (false);
+}
+
+Subnet6::Subnet6(const IOAddress& prefix, uint8_t length,
+                 const Triplet<uint32_t>& t1,
+                 const Triplet<uint32_t>& t2,
+                 const Triplet<uint32_t>& preferred_lifetime,
+                 const Triplet<uint32_t>& valid_lifetime,
+                 const SubnetID id)
+    : Subnet(prefix, length, id), Network6() {
+    if (!prefix.isV6()) {
+        isc_throw(BadValue, "Non IPv6 prefix " << prefix
+                  << " specified in subnet6");
+    }
+
+    // Timers.
+    setT1(t1);
+    setT2(t2);
+    setPreferred(preferred_lifetime);
+    setValid(valid_lifetime);
+}
+
+Subnet6Ptr
+Subnet6::create(const IOAddress& prefix, uint8_t length,
+                const Triplet<uint32_t>& t1,
+                const Triplet<uint32_t>& t2,
+                const Triplet<uint32_t>& preferred_lifetime,
+                const Triplet<uint32_t>& valid_lifetime,
+                const SubnetID id) {
+    Subnet6Ptr subnet = boost::make_shared<Subnet6>
+        (prefix, length, t1, t2, preferred_lifetime, valid_lifetime, id);
+    // IA_NA
+    subnet->setAllocator(Lease::TYPE_NA,
+                         boost::make_shared<IterativeAllocator>
+                         (Lease::TYPE_NA, subnet));
+    subnet->setAllocationState(Lease::TYPE_NA,
+                               SubnetIterativeAllocationState::create(subnet));
+    // IA_TA
+    subnet->setAllocator(Lease::TYPE_TA,
+                         boost::make_shared<IterativeAllocator>
+                         (Lease::TYPE_TA, subnet));
+    subnet->setAllocationState(Lease::TYPE_TA,
+                               SubnetIterativeAllocationState::create(subnet));
+    // IA_PD
+    subnet->setAllocator(Lease::TYPE_PD,
+                         boost::make_shared<IterativeAllocator>
+                         (Lease::TYPE_PD, subnet));
+    subnet->setAllocationState(Lease::TYPE_PD,
+                               SubnetIterativeAllocationState::create(subnet));
+    return (subnet);
+}
+
+void Subnet6::checkType(Lease::Type type) const {
+    if ((type != Lease::TYPE_NA) && (type != Lease::TYPE_TA) && (type != Lease::TYPE_PD)) {
+        isc_throw(BadValue, "Invalid Pool type: " << Lease::typeToText(type)
+                  << "(" << static_cast<int>(type)
+                  << "), must be TYPE_NA, TYPE_TA or TYPE_PD for Subnet6");
+    }
+}
+
+Subnet6Ptr
+Subnet6::getNextSubnet(const Subnet6Ptr& first_subnet) const {
+    SharedNetwork6Ptr network;
+    getSharedNetwork(network);
+    if (network) {
+        return (network->getNextSubnet(first_subnet, getID()));
+    }
+
+    return (Subnet6Ptr());
+}
+
+Subnet6Ptr
+Subnet6::getNextSubnet(const Subnet6Ptr& first_subnet,
+                       const ClientClasses& client_classes) const {
+    SharedNetwork6Ptr network;
+    getSharedNetwork(network);
+    // We can only get next subnet if shared network has been defined for
+    // the current subnet.
+    if (network) {
+        Subnet6Ptr subnet;
+        do {
+            // Use subnet identifier of this subnet if this is the first
+            // time we're calling getNextSubnet. Otherwise, use the
+            // subnet id of the previously returned subnet.
+            SubnetID subnet_id = subnet ? subnet->getID() : getID();
+            subnet = network->getNextSubnet(first_subnet, subnet_id);
+            // If client classes match the subnet, return it. Otherwise,
+            // try another subnet.
+            if (subnet && subnet->clientSupported(client_classes)) {
+                return (subnet);
+            }
+        } while (subnet);
+    }
+
+    // No subnet found.
+    return (Subnet6Ptr());
+}
+
+bool
+Subnet6::clientSupported(const isc::dhcp::ClientClasses& client_classes) const {
+    NetworkPtr network;
+    getSharedNetwork(network);
+    if (network && !network->clientSupported(client_classes)) {
+        return (false);
+    }
+
+    return (Network6::clientSupported(client_classes));
+}
+
+data::ElementPtr
+Subnet::toElement() const {
+    ElementPtr map = Element::createMap();
+
+    // Add user-context
+    contextToElement(map);
+
+    // Set subnet id
+    SubnetID id = getID();
+    map->set("id", Element::create(static_cast<long long>(id)));
+
+    // Set subnet
+    map->set("subnet", Element::create(toText()));
+
+    return (map);
+}
+
+void
+Subnet4::createAllocators() {
+    auto allocator_type = getAllocatorType();
+    if (allocator_type.empty()) {
+        allocator_type = getDefaultAllocatorType();
+    }
+    if (allocator_type == "random") {
+        setAllocator(Lease::TYPE_V4,
+                     boost::make_shared<RandomAllocator>
+                     (Lease::TYPE_V4, shared_from_this()));
+        setAllocationState(Lease::TYPE_V4, SubnetAllocationStatePtr());
+
+        for (auto pool : pools_) {
+            pool->setAllocationState(PoolRandomAllocationState::create(pool));
+        }
+
+    } else if (allocator_type == "flq") {
+        setAllocator(Lease::TYPE_V4,
+                     boost::make_shared<FreeLeaseQueueAllocator>
+                     (Lease::TYPE_V4, shared_from_this()));
+        setAllocationState(Lease::TYPE_V4, SubnetAllocationStatePtr());
+
+        for (auto pool : pools_) {
+            pool->setAllocationState(PoolFreeLeaseQueueAllocationState::create(pool));
+        }
+
+    } else {
+        setAllocator(Lease::TYPE_V4,
+                     boost::make_shared<IterativeAllocator>
+                     (Lease::TYPE_V4, shared_from_this()));
+        setAllocationState(Lease::TYPE_V4,
+                           SubnetIterativeAllocationState::create(shared_from_this()));
+
+        for (auto pool : pools_) {
+            pool->setAllocationState(PoolIterativeAllocationState::create(pool));
+        }
+    }
+}
+
+data::ElementPtr
+Subnet4::toElement() const {
+    // Prepare the map
+    ElementPtr map = Subnet::toElement();
+    ElementPtr network_map = Network4::toElement();
+
+    merge(map, network_map);
+
+    // Set DHCP4o6
+    const Cfg4o6& d4o6 = get4o6();
+    isc::data::merge(map, d4o6.toElement());
+
+    // Set pools
+    const auto& pools = getPools(Lease::TYPE_V4);
+    ElementPtr pool_list = Element::createList();
+    for (const auto& pool : pools) {
+        // Add the formatted pool to the list
+        pool_list->add(pool->toElement());
+    }
+    map->set("pools", pool_list);
+
+    return (map);
+}
+
+std::pair<IOAddress, uint8_t>
+Subnet4::parsePrefix(const std::string& prefix) {
+    std::pair<IOAddress, uint8_t> parsed = Subnet::parsePrefixCommon(prefix);
+    if (!parsed.first.isV4() || parsed.first.isV4Zero() ||
+        (parsed.second > 32) || (parsed.second == 0)) {
+        isc_throw(BadValue, "unable to parse invalid IPv4 prefix " << prefix);
+    }
+    return (parsed);
+}
+
+void
+Subnet6::createAllocators() {
+    auto allocator_type = getAllocatorType();
+    if (allocator_type.empty()) {
+        allocator_type = getDefaultAllocatorType();
+    }
+    if (allocator_type == "random") {
+        setAllocator(Lease::TYPE_NA,
+                     boost::make_shared<RandomAllocator>
+                     (Lease::TYPE_NA, shared_from_this()));
+        setAllocator(Lease::TYPE_TA,
+                     boost::make_shared<RandomAllocator>
+                     (Lease::TYPE_TA, shared_from_this()));
+        setAllocationState(Lease::TYPE_NA, SubnetAllocationStatePtr());
+        setAllocationState(Lease::TYPE_TA, SubnetAllocationStatePtr());
+
+    } else if (allocator_type == "flq") {
+        isc_throw(BadValue, "Free Lease Queue allocator is not supported for IPv6 address pools");
+
+    } else {
+        setAllocator(Lease::TYPE_NA,
+                     boost::make_shared<IterativeAllocator>
+                     (Lease::TYPE_NA, shared_from_this()));
+        setAllocationState(Lease::TYPE_NA, SubnetIterativeAllocationState::create(shared_from_this()));
+        setAllocationState(Lease::TYPE_TA, SubnetIterativeAllocationState::create(shared_from_this()));
+    }
+
+    auto pd_allocator_type = getPdAllocatorType();
+    if (pd_allocator_type.empty()) {
+        pd_allocator_type = getDefaultPdAllocatorType();
+    }
+    // Repeat the same for the delegated prefix allocator.
+    if (pd_allocator_type == "random") {
+        setAllocator(Lease::TYPE_PD,
+                     boost::make_shared<RandomAllocator>
+                     (Lease::TYPE_PD, shared_from_this()));
+        setAllocationState(Lease::TYPE_PD, SubnetAllocationStatePtr());
+
+    } else  if (pd_allocator_type == "flq") {
+        setAllocator(Lease::TYPE_PD,
+                     boost::make_shared<FreeLeaseQueueAllocator>
+                     (Lease::TYPE_PD, shared_from_this()));
+        setAllocationState(Lease::TYPE_PD, SubnetAllocationStatePtr());
+
+    } else {
+        setAllocator(Lease::TYPE_PD,
+                     boost::make_shared<IterativeAllocator>
+                     (Lease::TYPE_PD, shared_from_this()));
+        setAllocationState(Lease::TYPE_PD, SubnetIterativeAllocationState::create(shared_from_this()));
+    }
+    // Create allocation states for NA pools.
+    for (auto pool : pools_) {
+        if (allocator_type == "random") {
+            pool->setAllocationState(PoolRandomAllocationState::create(pool));
+        } else {
+            pool->setAllocationState(PoolIterativeAllocationState::create(pool));
+        }
+    }
+    // Create allocation states for TA pools.
+    for (auto pool : pools_ta_) {
+        if (allocator_type == "random") {
+            pool->setAllocationState(PoolRandomAllocationState::create(pool));
+        } else {
+            pool->setAllocationState(PoolIterativeAllocationState::create(pool));
+        }
+    }
+    // Create allocation states for PD pools.
+    for (auto pool : pools_pd_) {
+        if (pd_allocator_type == "random") {
+            pool->setAllocationState(PoolRandomAllocationState::create(pool));
+        } else if (pd_allocator_type == "flq") {
+            pool->setAllocationState(PoolFreeLeaseQueueAllocationState::create(pool));
+        } else {
+            pool->setAllocationState(PoolIterativeAllocationState::create(pool));
+        }
+    }
+}
+
+data::ElementPtr
+Subnet6::toElement() const {
+    // Prepare the map
+    ElementPtr map = Subnet::toElement();
+    ElementPtr network_map = Network6::toElement();
+
+    merge(map, network_map);
+
+    // Set pools
+    const auto& pools = getPools(Lease::TYPE_NA);
+    ElementPtr pool_list = Element::createList();
+    for (const auto& pool : pools) {
+        // Add the formatted pool to the list
+        pool_list->add(pool->toElement());
+    }
+    map->set("pools", pool_list);
+
+    // Set pd-pools
+    const auto& pdpools = getPools(Lease::TYPE_PD);
+    ElementPtr pdpool_list = Element::createList();
+    for (const auto& pool : pdpools) {
+        // Add the formatted pool to the list
+        pdpool_list->add(pool->toElement());
+    }
+    map->set("pd-pools", pdpool_list);
+
+    return (map);
+}
+
+std::pair<IOAddress, uint8_t>
+Subnet6::parsePrefix(const std::string& prefix) {
+    std::pair<IOAddress, uint8_t> parsed = Subnet::parsePrefixCommon(prefix);
+    if (!parsed.first.isV6() || parsed.first.isV6Zero() ||
+        (parsed.second > 128) || (parsed.second == 0)) {
+        isc_throw(BadValue, "unable to parse invalid IPv6 prefix " << prefix);
+    }
+    return (parsed);
+}
+
+}  // namespace dhcp
+}  // namespace isc