shared_network.cc

Go to the documentation of this file.

// Copyright (C) 2017-2024 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 <exceptions/exceptions.h>
#include <dhcpsrv/shared_network.h>
#include <boost/make_shared.hpp>
 
using namespace isc;
using namespace isc::data;
using namespace isc::dhcp;
 
namespace {

class Impl {
public:

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static void add(SubnetCollectionType& subnets, const SubnetPtrType& subnet) {
        //  Subnet must be non-null.
        if (!subnet) {
            isc_throw(BadValue, "null pointer specified when adding a subnet"
                      " to a shared network");
        }
 
        // Check if a subnet with this id already exists.
        if (getSubnet<SubnetPtrType>(subnets, subnet->getID())) {
            isc_throw(DuplicateSubnetID, "attempted to add subnet with a"
                      " duplicated subnet identifier " << subnet->getID());
        } else if (getSubnet<SubnetPtrType>(subnets, subnet->toText())) {
            isc_throw(DuplicateSubnetID, "attempted to add subnet with a"
                      " duplicated subnet prefix " << subnet->toText());
        }
 
        // Check if the subnet is already associated with some network.
        NetworkPtr network;
        subnet->getSharedNetwork(network);
        if (network) {
            isc_throw(InvalidOperation, "subnet " << subnet->getID()
                      << " being added to a shared network"
                      " already belongs to a shared network");
        }
 
        // Add a subnet to the collection of subnets for this shared network.
        static_cast<void>(subnets.insert(subnet));
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static bool replace(SubnetCollectionType& subnets,
                        const SubnetPtrType& subnet) {
 
        // Check if the new subnet is already associated with some network.
        NetworkPtr network;
        subnet->getSharedNetwork(network);
        if (network) {
            isc_throw(InvalidOperation, "subnet " << subnet->getID()
                      << " being replaced in a shared network"
                      " already belongs to a shared network");
        }
 
        // Get the subnet with the same ID.
        const SubnetID& subnet_id = subnet->getID();
        auto& index = subnets.template get<SubnetSubnetIdIndexTag>();
        auto subnet_it = index.find(subnet_id);
        if (subnet_it == index.end()) {
            // Nothing to replace: return false to get the whole operation
            // to be rollbacked.
            return (false);
        }
 
        // Replace it.
        return (index.replace(subnet_it, subnet));
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static SubnetPtrType del(SubnetCollectionType& subnets,
                             const SubnetID& subnet_id) {
        auto& index = subnets.template get<SubnetSubnetIdIndexTag>();
        auto subnet_it = index.find(subnet_id);
        if (subnet_it == index.end()) {
            isc_throw(BadValue, "unable to delete subnet " << subnet_id
                      << " from shared network. Subnet doesn't belong"
                      " to this shared network");
        }
        auto subnet = *subnet_it;
        index.erase(subnet_it);
        return (subnet);
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static SubnetPtrType getSubnet(const SubnetCollectionType& subnets,
                                   const SubnetID& subnet_id) {
        auto const& index = subnets.template get<SubnetSubnetIdIndexTag>();
        auto subnet_it = index.find(subnet_id);
        if (subnet_it != index.cend()) {
            return (*subnet_it);
        }
 
        // Subnet not found.
        return (SubnetPtrType());
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static SubnetPtrType getSubnet(const SubnetCollectionType& subnets,
                                   const std::string& subnet_prefix) {
        auto const& index = subnets.template get<SubnetPrefixIndexTag>();
        auto subnet_it = index.find(subnet_prefix);
        if (subnet_it != index.cend()) {
            return (*subnet_it);
        }
 
        // Subnet not found.
        return (SubnetPtrType());
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static SubnetPtrType getNextSubnet(const SubnetCollectionType& subnets,
                                       const SubnetPtrType& first_subnet,
                                       const SubnetID& current_subnet) {
        // It is ok to have a shared network without any subnets, but in this
        // case there is nothing else we can return but null pointer.
        if (subnets.empty()) {
            return (SubnetPtrType());
        }
 
        // Need to retrieve an iterator to the current subnet first. The
        // subnet must exist in this container, thus we throw if the iterator
        // is not found.
        auto const& index = subnets.template get<SubnetSubnetIdIndexTag>();
        auto subnet_it = index.find(current_subnet);
        if (subnet_it == index.cend()) {
            isc_throw(BadValue, "no such subnet " << current_subnet
                      << " within shared network");
        }
 
        // Step to a next subnet.
        if (++subnet_it == subnets.cend()) {
            // If we reached the end of the container, start over from the
            // beginning.
            subnet_it = subnets.cbegin();
        }
 
        // Check if we have made a full circle. If we did, return a null pointer
        // to indicate that there are no more subnets.
        if ((*subnet_it)->getID() == first_subnet->getID()) {
            return (SubnetPtrType());
        }
 
        // Got the next subnet, so return it.
        return (*subnet_it);
    }

    template<typename SubnetPtrType, typename SubnetCollectionType>
    static SubnetPtrType getPreferredSubnet(const SubnetCollectionType& subnets,
                                            const SubnetPtrType& selected_subnet,
                                            const Lease::Type& lease_type) {
 
        auto preferred_subnet = selected_subnet;
        for (auto const& s : subnets) {
            // It doesn't make sense to check the subnet against itself.
            if (preferred_subnet == s) {
                continue;
            }
            if (s->getClientClasses() != selected_subnet->getClientClasses()) {
                continue;
            }
            auto current_subnet_state = s->getAllocationState(lease_type);
            if (!current_subnet_state) {
                continue;
            }
            auto preferred_subnet_state = preferred_subnet->getAllocationState(lease_type);
            if (!preferred_subnet_state) {
                continue;
            }
            // The currently checked subnet has more recent time than the
            // currently preferred subnet. Update the preferred subnet
            // instance.
            if (current_subnet_state->getLastAllocatedTime() >
                preferred_subnet_state->getLastAllocatedTime()) {
                preferred_subnet = s;
            }
        }
        return (preferred_subnet);
    }
};
 
} // end of anonymous namespace
 
namespace isc {
namespace dhcp {
 
SharedNetwork4Ptr
SharedNetwork4::create(const std::string& name) {
    return (boost::make_shared<SharedNetwork4>(name));
}
 
void
SharedNetwork4::add(const Subnet4Ptr& subnet) {
    Impl::add(subnets_, subnet);
    // Associate the subnet with this network.
    subnet->setSharedNetwork(shared_from_this());
    subnet->setSharedNetworkName(name_);
}
 
bool
SharedNetwork4::replace(const Subnet4Ptr& subnet) {
    // Subnet must be non-null.
    if (!subnet) {
        isc_throw(BadValue, "null pointer specified when adding a subnet"
                  " to a shared network");
    }
    const Subnet4Ptr& old = getSubnet(subnet->getID());
    bool ret = Impl::replace(subnets_, subnet);
    if (ret) {
        // Associate the subnet with this network.
        subnet->setSharedNetwork(shared_from_this());
        subnet->setSharedNetworkName(name_);
        // Deassociate the previous subnet.
        old->setSharedNetwork(NetworkPtr());
        old->setSharedNetworkName("");
    }
    return (ret);
}
 
void
SharedNetwork4::del(const SubnetID& subnet_id) {
    Subnet4Ptr subnet = Impl::del<Subnet4Ptr>(subnets_, subnet_id);
    subnet->setSharedNetwork(NetworkPtr());
    subnet->setSharedNetworkName("");
}
 
void
SharedNetwork4::delAll() {
    for (auto const& subnet : subnets_) {
        subnet->setSharedNetwork(NetworkPtr());
        subnet->setSharedNetworkName("");
    }
    subnets_.clear();
}
 
Subnet4Ptr
SharedNetwork4::getSubnet(const SubnetID& subnet_id) const {
    return (Impl::getSubnet<Subnet4Ptr>(subnets_, subnet_id));
}
 
Subnet4Ptr
SharedNetwork4::getSubnet(const std::string& subnet_prefix) const {
    return (Impl::getSubnet<Subnet4Ptr>(subnets_, subnet_prefix));
}
 
ConstSubnet4Ptr
SharedNetwork4::getNextSubnet(const ConstSubnet4Ptr& first_subnet,
                              const SubnetID& current_subnet) const {
    return (Impl::getNextSubnet(subnets_, first_subnet, current_subnet));
}
 
ConstSubnet4Ptr
SharedNetwork4::getPreferredSubnet(const ConstSubnet4Ptr& selected_subnet) const {
    return (Impl::getPreferredSubnet(subnets_, selected_subnet, Lease::TYPE_V4));
}
 
bool
SharedNetwork4::subnetsIncludeMatchClientId(const ConstSubnet4Ptr& first_subnet,
                                            const ClientClasses& client_classes) {
    for (ConstSubnet4Ptr subnet = first_subnet; subnet;
         subnet = subnet->getNextSubnet(first_subnet, client_classes)) {
        if (subnet->getMatchClientId()) {
            return (true);
        }
    }
    return (false);
}
 
ElementPtr
SharedNetwork4::toElement() const {
    ElementPtr map = Network4::toElement();
 
    // Set shared network name.
    if (!name_.empty()) {
        map->set("name", Element::create(name_));
    }
 
    ElementPtr subnet4 = Element::createList();
    for (auto const& subnet : subnets_) {
        subnet4->add(subnet->toElement());
    }
 
    map->set("subnet4", subnet4);
 
    return (map);
}
 
SharedNetwork6Ptr
SharedNetwork6::create(const std::string& name) {
    return (boost::make_shared<SharedNetwork6>(name));
}
 
void
SharedNetwork6::add(const Subnet6Ptr& subnet) {
    Impl::add(subnets_, subnet);
    // Associate the subnet with this network.
    subnet->setSharedNetwork(shared_from_this());
    subnet->setSharedNetworkName(name_);
}
 
bool
SharedNetwork6::replace(const Subnet6Ptr& subnet) {
    // Subnet must be non-null.
    if (!subnet) {
        isc_throw(BadValue, "null pointer specified when adding a subnet"
                  " to a shared network");
    }
    const Subnet6Ptr& old = getSubnet(subnet->getID());
    bool ret = Impl::replace(subnets_, subnet);
    if (ret) {
        // Associate the subnet with this network.
        subnet->setSharedNetwork(shared_from_this());
        subnet->setSharedNetworkName(name_);
        // Deassociate the previous subnet.
        old->setSharedNetwork(NetworkPtr());
        old->setSharedNetworkName("");
    }
    return (ret);
}
 
void
SharedNetwork6::del(const SubnetID& subnet_id) {
    Subnet6Ptr subnet = Impl::del<Subnet6Ptr>(subnets_, subnet_id);
    subnet->setSharedNetwork(NetworkPtr());
    subnet->setSharedNetworkName("");
}
 
void
SharedNetwork6::delAll() {
    for (auto const& subnet : subnets_) {
        subnet->setSharedNetwork(NetworkPtr());
    }
    subnets_.clear();
}
 
Subnet6Ptr
SharedNetwork6::getSubnet(const SubnetID& subnet_id) const {
    return (Impl::getSubnet<Subnet6Ptr>(subnets_, subnet_id));
}
 
Subnet6Ptr
SharedNetwork6::getSubnet(const std::string& subnet_prefix) const {
    return (Impl::getSubnet<Subnet6Ptr>(subnets_, subnet_prefix));
}
 
ConstSubnet6Ptr
SharedNetwork6::getNextSubnet(const ConstSubnet6Ptr& first_subnet,
                              const SubnetID& current_subnet) const {
    return (Impl::getNextSubnet(subnets_, first_subnet, current_subnet));
}
 
ConstSubnet6Ptr
SharedNetwork6::getPreferredSubnet(const ConstSubnet6Ptr& selected_subnet,
                                   const Lease::Type& lease_type) const {
    return (Impl::getPreferredSubnet(subnets_, selected_subnet, lease_type));
}
 
ElementPtr
SharedNetwork6::toElement() const {
    ElementPtr map = Network6::toElement();
 
    // Set shared network name.
    if (!name_.empty()) {
        map->set("name", Element::create(name_));
    }
 
    ElementPtr subnet6 = Element::createList();
    for (auto const& subnet : subnets_) {
        subnet6->add(subnet->toElement());
    }
 
    map->set("subnet6", subnet6);
 
    return (map);
}
 
} // end of namespace isc::dhcp
} // end of namespace isc