pool.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 POOL_H
#define POOL_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <cc/user_context.h>
#include <dhcp/classify.h>
#include <dhcp/option6_pdexclude.h>
#include <dhcpsrv/allocation_state.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/ip_range_permutation.h>
#include <util/bigints.h>
 
#include <boost/shared_ptr.hpp>
 
#include <vector>
 
namespace isc {
namespace dhcp {
 
class Pool : public isc::data::UserContext, public isc::data::CfgToElement {
 
public:
 
    uint64_t getID() const {
        return (id_);
    }
 
    void setID(const uint64_t id) {
        id_ = id;
    }
 
    const isc::asiolink::IOAddress& getFirstAddress() const {
        return (first_);
    }
 
    const isc::asiolink::IOAddress& getLastAddress() const {
        return (last_);
    }
 
    bool inRange(const isc::asiolink::IOAddress& addr) const;
 
    Lease::Type getType() const {
        return (type_);
    }
 
    virtual std::string toText() const;
 
    virtual ~Pool() = default;
 
    isc::util::uint128_t getCapacity() const {
        return (capacity_);
    }
 
    CfgOptionPtr getCfgOption() {
        return (cfg_option_);
    }
 
    ConstCfgOptionPtr getCfgOption() const {
        return (cfg_option_);
    }
 
    bool clientSupported(const ClientClasses& client_classes) const;
 
    void allowClientClass(const ClientClass& class_name);
 
    const ClientClass& getClientClass() const {
        return (client_class_);
    }
 
    void requireClientClass(const ClientClass& class_name) {
        if (!required_classes_.contains(class_name)) {
            required_classes_.insert(class_name);
        }
    }
 
    const ClientClasses& getRequiredClasses() const {
        return (required_classes_);
    }
 
    AllocationStatePtr getAllocationState() const {
        return (allocation_state_);
    }
 
    void setAllocationState(const AllocationStatePtr& allocation_state) {
        allocation_state_ = allocation_state;
    }
 
    virtual data::ElementPtr toElement() const;
 
protected:
 
    Pool(Lease::Type type,
         const isc::asiolink::IOAddress& first,
         const isc::asiolink::IOAddress& last);
 
    uint64_t id_;
 
    isc::asiolink::IOAddress first_;
 
    isc::asiolink::IOAddress last_;
 
    Lease::Type type_;
 
    isc::util::uint128_t capacity_;
 
    CfgOptionPtr cfg_option_;
 
    ClientClass client_class_;
 
    ClientClasses required_classes_;
 
    data::ConstElementPtr user_context_;
 
    AllocationStatePtr allocation_state_;
};
 
class Pool4;
 
typedef boost::shared_ptr<Pool4> Pool4Ptr;
 
class Pool4 : public Pool {
public:
    Pool4(const isc::asiolink::IOAddress& first,
          const isc::asiolink::IOAddress& last);
 
    Pool4(const isc::asiolink::IOAddress& prefix,
          uint8_t prefix_len);
 
    static Pool4Ptr create(const isc::asiolink::IOAddress& first,
                           const isc::asiolink::IOAddress& last);
 
    static Pool4Ptr create(const isc::asiolink::IOAddress& prefix,
                           uint8_t prefix_len);
 
    virtual data::ElementPtr toElement() const;
};
 
class Pool6;
 
typedef boost::shared_ptr<Pool6> Pool6Ptr;
 
class Pool6 : public Pool {
public:
 
    Pool6(Lease::Type type, const isc::asiolink::IOAddress& first,
          const isc::asiolink::IOAddress& last);
 
    Pool6(Lease::Type type, const isc::asiolink::IOAddress& prefix,
          uint8_t prefix_len, uint8_t delegated_len = 128);
 
    Pool6(const asiolink::IOAddress& prefix, const uint8_t prefix_len,
          const uint8_t delegated_len,
          const asiolink::IOAddress& excluded_prefix,
          const uint8_t excluded_prefix_len);
 
    static Pool6Ptr create(Lease::Type type,
                           const isc::asiolink::IOAddress& first,
                           const isc::asiolink::IOAddress& last);
 
    static Pool6Ptr create(Lease::Type type,
                           const isc::asiolink::IOAddress& prefix,
                           uint8_t prefix_len,
                           uint8_t delegated_len = 128);
 
    static Pool6Ptr create(const asiolink::IOAddress& prefix,
                           const uint8_t prefix_len,
                           const uint8_t delegated_len,
                           const asiolink::IOAddress& excluded_prefix,
                           const uint8_t excluded_prefix_len);
 
    Lease::Type getType() const {
        return (type_);
    }
 
    uint8_t getLength() const {
        return (prefix_len_);
    }
 
    Option6PDExcludePtr getPrefixExcludeOption() const {
        return (pd_exclude_option_);
    }
 
    virtual data::ElementPtr toElement() const;
 
    virtual std::string toText() const;
 
private:
 
    void init(const Lease::Type& type,
              const asiolink::IOAddress& prefix,
              const uint8_t prefix_len,
              const uint8_t delegated_len,
              const asiolink::IOAddress& excluded_prefix,
              const uint8_t excluded_prefix_len);
 
    uint8_t prefix_len_;
 
    Option6PDExcludePtr pd_exclude_option_;
 
};
 
typedef boost::shared_ptr<Pool> PoolPtr;
 
typedef std::vector<PoolPtr> PoolCollection;
 
} // end of isc::dhcp namespace
} // end of isc namespace
 
#endif // POOL_H