shared_network.h

Go to the documentation of this file.

// Copyright (C) 2017-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 SHARED_NETWORK_H
#define SHARED_NETWORK_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/subnet_id.h>
#include <boost/enable_shared_from_this.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/hashed_index.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/shared_ptr.hpp>
#include <string>
 
namespace isc {
namespace dhcp {
 
struct SharedNetworkRandomAccessIndexTag { };
 
struct SharedNetworkIdIndexTag { };
 
struct SharedNetworkNameIndexTag { };
 
struct SharedNetworkServerIdIndexTag { };
 
struct SharedNetworkModificationTimeIndexTag { };
 
class SharedNetwork4;
 
typedef boost::shared_ptr<SharedNetwork4> SharedNetwork4Ptr;
 
class SharedNetwork4 : public virtual Network4,
                       public boost::enable_shared_from_this<SharedNetwork4> {
public:
 
    explicit SharedNetwork4(const std::string& name)
        : name_(name), subnets_() {
    }
 
    static SharedNetwork4Ptr create(const std::string& name);
 
    std::string getName() const {
        return (name_);
    }
 
    void setName(const std::string& name) {
        name_ = name;
    }
 
    void add(const Subnet4Ptr& subnet);
 
    bool replace(const Subnet4Ptr& subnet);
 
    void del(const SubnetID& subnet_id);
 
    void delAll();
 
    const Subnet4SimpleCollection* getAllSubnets() const {
        return (&subnets_);
    }
 
    Subnet4Ptr getSubnet(const SubnetID& subnet_id) const;
 
    Subnet4Ptr getSubnet(const std::string& subnet_prefix) const;
 
    Subnet4Ptr getNextSubnet(const Subnet4Ptr& first_subnet,
                             const SubnetID& current_subnet) const;
 
    Subnet4Ptr getPreferredSubnet(const Subnet4Ptr& selected_subnet) const;
 
    static
    bool subnetsIncludeMatchClientId(const Subnet4Ptr& first_subnet,
                                     const ClientClasses& client_classes);
 
    virtual data::ElementPtr toElement() const;
 
    virtual std::string getLabel() const {
        std::stringstream ss;
        ss << "shared-network " << name_;
        return (ss.str());
    }
 
private:
 
    std::string name_;
 
    Subnet4SimpleCollection subnets_;
};
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the shared networks.
    SharedNetwork4Ptr,
    boost::multi_index::indexed_by<
        // First is the random access index allowing for accessing objects
        // just like we'd do with vector.
        boost::multi_index::random_access<
            boost::multi_index::tag<SharedNetworkRandomAccessIndexTag>
        >,
        // Second index allows for access by shared network id.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::tag<SharedNetworkIdIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement, uint64_t,
                                              &data::BaseStampedElement::getId>
        >,
        // Third index allows for access by shared network's name.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SharedNetworkNameIndexTag>,
            boost::multi_index::const_mem_fun<SharedNetwork4, std::string,
                                              &SharedNetwork4::getName>
        >,
        // Fourth index allows for access by server identifier specified for the
        // network.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SharedNetworkServerIdIndexTag>,
            boost::multi_index::const_mem_fun<Network4, asiolink::IOAddress,
                                              &Network4::getServerId>
        >,
        // Fifth index allows for searching using subnet modification time.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SharedNetworkModificationTimeIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement,
                                              boost::posix_time::ptime,
                                              &data::BaseStampedElement::getModificationTime>
        >
    >
> SharedNetwork4Collection;
 
class SharedNetwork6;
 
typedef boost::shared_ptr<SharedNetwork6> SharedNetwork6Ptr;
 
class SharedNetwork6 : public virtual Network6,
                       public boost::enable_shared_from_this<SharedNetwork6> {
public:
 
    explicit SharedNetwork6(const std::string& name)
        : name_(name), subnets_() {
    }
 
    static SharedNetwork6Ptr create(const std::string& name);
 
    std::string getName() const {
        return (name_);
    }
 
    void setName(const std::string& name) {
        name_ = name;
    }
 
    void add(const Subnet6Ptr& subnet);
 
    bool replace(const Subnet6Ptr& subnet);
 
    void del(const SubnetID& subnet_id);
 
    void delAll();
 
    const Subnet6SimpleCollection* getAllSubnets() const {
        return (&subnets_);
    }
 
    Subnet6Ptr getSubnet(const SubnetID& subnet_id) const;
 
    Subnet6Ptr getSubnet(const std::string& subnet_prefix) const;
 
    Subnet6Ptr getNextSubnet(const Subnet6Ptr& first_subnet,
                             const SubnetID& current_subnet) const;
 
    Subnet6Ptr getPreferredSubnet(const Subnet6Ptr& selected_subnet,
                                  const Lease::Type& lease_type) const;
 
    virtual data::ElementPtr toElement() const;
 
    virtual std::string getLabel() const {
        std::stringstream ss;
        ss << "shared-network " << name_;
        return (ss.str());
    }
 
private:
 
    std::string name_;
 
    Subnet6SimpleCollection subnets_;
};
 
typedef boost::multi_index_container<
    // Multi index container holds pointers to the shared networks.
    SharedNetwork6Ptr,
    boost::multi_index::indexed_by<
        // First is the random access index allowing for accessing objects
        // just like we'd do with vector.
        boost::multi_index::random_access<
            boost::multi_index::tag<SharedNetworkRandomAccessIndexTag>
        >,
        // Second index allows for access by shared network id.
        boost::multi_index::hashed_non_unique<
            boost::multi_index::tag<SharedNetworkIdIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement, uint64_t,
                                              &data::BaseStampedElement::getId>
        >,
        // Third index allows for access by shared network's name.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<SharedNetworkNameIndexTag>,
            boost::multi_index::const_mem_fun<SharedNetwork6, std::string,
                                              &SharedNetwork6::getName>
        >,
        // Fourth index allows for searching using subnet modification time.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<SharedNetworkModificationTimeIndexTag>,
            boost::multi_index::const_mem_fun<data::BaseStampedElement,
                                              boost::posix_time::ptime,
                                              &data::BaseStampedElement::getModificationTime>
        >
    >
> SharedNetwork6Collection;
 
template<typename ReturnPtrType, typename CollectionType>
class SharedNetworkFetcher {
public:
 
    static ReturnPtrType get(const CollectionType& collection, const std::string& name) {
        auto& index = collection.template get<SharedNetworkNameIndexTag>();
        auto sn = index.find(name);
        if (sn != index.end()) {
            return (*sn);
        }
        // No network found. Return null pointer.
        return (ReturnPtrType());
    }
};
 
using SharedNetworkFetcher4 = SharedNetworkFetcher<SharedNetwork4Ptr, SharedNetwork4Collection>;
 
using SharedNetworkFetcher6 = SharedNetworkFetcher<SharedNetwork6Ptr, SharedNetwork6Collection>;
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif // SHARED_NETWORK_H