cfg_shared_networks.h

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/.
 
#ifndef CFG_SHARED_NETWORKS_H
#define CFG_SHARED_NETWORKS_H
 
#include <asiolink/io_address.h>
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <exceptions/exceptions.h>
#include <dhcpsrv/shared_network.h>
#include <boost/foreach.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
 
namespace isc {
namespace dhcp {
 
template<typename SharedNetworkPtrType, typename SharedNetworkCollection>
class CfgSharedNetworks : public data::CfgToElement {
public:
    const SharedNetworkCollection* getAll() const {
        return (&networks_);
    }
 
    void add(const SharedNetworkPtrType& network) {
        if (getByName(network->getName())) {
            isc_throw(BadValue, "duplicate network '" << network->getName() <<
                      "' found in the configuration");
        }
 
        static_cast<void>(networks_.push_back(network));
    }
 
    void del(const std::string& name) {
        auto& index = networks_.template get<SharedNetworkNameIndexTag>();
        auto shared_network = index.find(name);
        if (shared_network != index.end()) {
            // Delete all subnets from the network
            (*shared_network)->delAll();
 
            // Then delete the network from the networks list.
            index.erase(shared_network);
        } else {
            isc_throw(BadValue, "unable to delete non-existing network '"
                      << name << "' from shared networks configuration");
        }
    }
 
    uint64_t del(const uint64_t id) {
        auto& index = networks_.template get<SharedNetworkIdIndexTag>();
        auto sn_range = index.equal_range(id);
 
        // For each shared network found, dereference the subnets belonging
        // to it.
        BOOST_FOREACH(auto const& it, sn_range) {
            it->delAll();
        }
 
        // Remove the shared networks.
        return (static_cast<uint64_t>(index.erase(id)));
    }
 
    SharedNetworkPtrType getByName(const std::string& name) const {
        auto const& index = networks_.template get<SharedNetworkNameIndexTag>();
        auto shared_network = index.find(name);
        if (shared_network != index.cend()) {
            return (*shared_network);
        }
        return (SharedNetworkPtrType());
    }
 
    virtual data::ElementPtr toElement() const {
        data::ElementPtr list = data::Element::createList();
 
        // Insert shared networks sorted by their names into the list.
        auto const& index = networks_.template get<SharedNetworkNameIndexTag>();
        for (auto const& shared_network : index) {
            list->add(shared_network->toElement());
        }
        return (list);
    }
 
    void merge(CfgOptionDefPtr cfg_def, CfgSharedNetworks& other) {
        auto& index = networks_.template get<SharedNetworkNameIndexTag>();
 
        // Iterate over the subnets to be merged. They will replace the existing
        // subnets with the same id. All new subnets will be inserted into this
        // configuration.
        auto const& other_networks = other.getAll();
        for (auto const& other_network : *other_networks) {
 
            // In theory we should drop subnet assignments from "other". The
            // idea being  those that come from the CB should not have subnets_
            // populated.  We will quietly throw them away, just in case.
            other_network->delAll();
 
            // Check if the other network exists in this config.
            auto existing_network = index.find(other_network->getName());
            if (existing_network != index.end()) {
 
                // Somehow the same instance is in both, skip it.
                if (*existing_network == other_network) {
                    continue;
                }
 
                // Network exists, which means we're updating it.
                // First we need to move its subnets to the new
                // version of the network.
                auto const subnets = (*existing_network)->getAllSubnets();
 
                auto copy_subnets(*subnets);
                for (auto const& subnet : copy_subnets) {
                    (*existing_network)->del(subnet->getID());
                    other_network->add(subnet);
                }
 
                // Now we discard the existing copy of the network.
                index.erase(existing_network);
            }
 
            // Create the network's options based on the given definitions.
            other_network->getCfgOption()->createOptions(cfg_def);
 
            // Encapsulate options, so that the DHCP server can effectively return
            // them to the clients without having to encapsulate them for each request.
            other_network->getCfgOption()->encapsulate();
 
            // Add the new/updated network.
            static_cast<void>(networks_.push_back(other_network));
        }
    }
 
protected:
 
    SharedNetworkCollection networks_;
};
 
class CfgSharedNetworks4 : public CfgSharedNetworks<SharedNetwork4Ptr,
                                                    SharedNetwork4Collection> {
public:
    bool hasNetworkWithServerId(const asiolink::IOAddress& server_id) const;
};
 
typedef boost::shared_ptr<CfgSharedNetworks4> CfgSharedNetworks4Ptr;
 
class CfgSharedNetworks6 : public CfgSharedNetworks<SharedNetwork6Ptr,
                                                    SharedNetwork6Collection> {
};
 
typedef boost::shared_ptr<CfgSharedNetworks6> CfgSharedNetworks6Ptr;
 
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // CFG_SHARED_NETWORKS_H