pool.h

Go to the documentation of this file.

// Copyright (C) 2012-2025 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/d2_client_cfg.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/ip_range_permutation.h>
#include <util/bigints.h>
#include <util/optional.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 isc::dhcp::ClientClass& class_name);

    const ClientClasses& getClientClasses() const {
        return (client_classes_);
    }

    ClientClasses& getMutableClientClasses() {
        return (client_classes_);
    }

    void addAdditionalClass(const ClientClass& class_name);

    const ClientClasses& getAdditionalClasses() const {
        return (additional_classes_);
    }

    ClientClasses& getMutableAdditionalClasses() {
        return (additional_classes_);
    }

    AllocationStatePtr getAllocationState() const {
        return (allocation_state_);
    }

    void setAllocationState(const AllocationStatePtr& allocation_state) {
        allocation_state_ = allocation_state;
    }

    virtual data::ElementPtr toElement() const;
 

    util::Optional<bool>
    getDdnsSendUpdates() const {
        return (ddns_send_updates_);
    }

    void setDdnsSendUpdates(const util::Optional<bool>& ddns_send_updates) {
        ddns_send_updates_ = ddns_send_updates;
    }

    util::Optional<bool>
    getDdnsOverrideNoUpdate() const {
        return (ddns_override_no_update_);
    }

    void setDdnsOverrideNoUpdate(const util::Optional<bool>& ddns_override_no_update) {
        ddns_override_no_update_ = ddns_override_no_update;
    }

    util::Optional<bool>
    getDdnsOverrideClientUpdate() const {
        return (ddns_override_client_update_);
    }

    void setDdnsOverrideClientUpdate(const util::Optional<bool>&
                                     ddns_override_client_update) {
        ddns_override_client_update_ = ddns_override_client_update;
    }

    util::Optional<D2ClientConfig::ReplaceClientNameMode>
    getDdnsReplaceClientNameMode() const {
        return (ddns_replace_client_name_mode_);
    }

    void
    setDdnsReplaceClientNameMode(const util::Optional<D2ClientConfig::ReplaceClientNameMode>&
                                 ddns_replace_client_name_mode) {
        ddns_replace_client_name_mode_ = ddns_replace_client_name_mode;
    }

    util::Optional<std::string>
    getDdnsGeneratedPrefix() const {
        return (ddns_generated_prefix_);
    }

    void setDdnsGeneratedPrefix(const util::Optional<std::string>& ddns_generated_prefix) {
        ddns_generated_prefix_ = ddns_generated_prefix;
    }

    util::Optional<std::string>
    getDdnsQualifyingSuffix() const {
        return (ddns_qualifying_suffix_);
    }

    void setDdnsQualifyingSuffix(const util::Optional<std::string>& ddns_qualifying_suffix) {
        ddns_qualifying_suffix_ = ddns_qualifying_suffix;
    }

    util::Optional<bool>
    getDdnsUpdateOnRenew() const {
        return (ddns_update_on_renew_);
    }

    void setDdnsUpdateOnRenew(const util::Optional<bool>& ddns_update_on_renew) {
        ddns_update_on_renew_ = ddns_update_on_renew;
    }

    util::Optional<std::string>
    getDdnsConflictResolutionMode() const {
        return (ddns_conflict_resolution_mode_);
    }

    void setDdnsConflictResolutionMode(const util::Optional<std::string>& ddns_conflict_resolution_mode) {
        ddns_conflict_resolution_mode_ = ddns_conflict_resolution_mode;
    }
 

    util::Optional<double>
    getDdnsTtlPercent() const {
        return (ddns_ttl_percent_);
    }

    void setDdnsTtlPercent(const util::Optional<double>& ddns_ttl_percent) {
        ddns_ttl_percent_ = ddns_ttl_percent;
    }

    util::Optional<uint32_t>
    getDdnsTtl() const {
        return (ddns_ttl_);
    }

    void setDdnsTtl(const util::Optional<uint32_t>& ddns_ttl) {
        ddns_ttl_ = ddns_ttl;
    }

    util::Optional<uint32_t>
    getDdnsTtlMin() const {
        return (ddns_ttl_min_);
    }

    void setDdnsTtlMin(const util::Optional<uint32_t>& ddns_ttl_min) {
        ddns_ttl_min_ = ddns_ttl_min;
    }

    util::Optional<uint32_t>
    getDdnsTtlMax() const {
        return (ddns_ttl_max_);
    }

    void setDdnsTtlMax(const util::Optional<uint32_t>& ddns_ttl_max) {
        ddns_ttl_max_ = ddns_ttl_max;
    }

    util::Optional<std::string>
    getHostnameCharSet() const {
        return (hostname_char_set_);
    }

    void setHostnameCharSet(const util::Optional<std::string>& hostname_char_set) {
        hostname_char_set_ = hostname_char_set;
    }

    util::Optional<std::string>
    getHostnameCharReplacement() const {
        return (hostname_char_replacement_);
    }

    void setHostnameCharReplacement(const util::Optional<std::string>&
                                    hostname_char_replacement) {
        hostname_char_replacement_ = hostname_char_replacement;
    }

    bool hasDdnsParameters() 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_;

    ClientClasses client_classes_;

    ClientClasses additional_classes_;

    data::ConstElementPtr user_context_;

    AllocationStatePtr allocation_state_;

    util::Optional<bool> ddns_send_updates_;

    util::Optional<bool> ddns_override_no_update_;

    util::Optional<bool> ddns_override_client_update_;

    util::Optional<D2ClientConfig::ReplaceClientNameMode> ddns_replace_client_name_mode_;

    util::Optional<std::string> ddns_generated_prefix_;

    util::Optional<std::string> ddns_qualifying_suffix_;

    util::Optional<bool> ddns_update_on_renew_;

    util::Optional<std::string> ddns_conflict_resolution_mode_;

    util::Optional<double> ddns_ttl_percent_;

    util::Optional<uint32_t> ddns_ttl_;

    util::Optional<uint32_t> ddns_ttl_min_;

    util::Optional<uint32_t> ddns_ttl_max_;

    util::Optional<std::string> hostname_char_set_;

    util::Optional<std::string> hostname_char_replacement_;
};
 
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