Current File : //proc/thread-self/root/backups/router/usr/local/include/kea/dhcpsrv/iterative_allocation_state.h
// Copyright (C) 2022-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 ITERATIVE_ALLOCATION_STATE_H
#define ITERATIVE_ALLOCATION_STATE_H
#include <asiolink/io_address.h>
#include <dhcpsrv/allocation_state.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/subnet.h>
#include <boost/shared_ptr.hpp>
#include <cstdint>
#include <map>
namespace isc {
namespace dhcp {
/// @brief Forward declaration of the @c SubnetIterativeAllocationState.
class SubnetIterativeAllocationState;
/// @brief Type of the pointer to the @c SubnetIterativeAllocationState.
typedef boost::shared_ptr<SubnetIterativeAllocationState> SubnetIterativeAllocationStatePtr;
/// @brief Subnet allocation state used by the iterative allocator.
///
/// It extends the base class with the mechanism to store the last
/// allocated address or delegated prefix. The iterative allocator
/// uses this information to pick the next address or delegated
/// prefix on the next allocation request.
class SubnetIterativeAllocationState : public SubnetAllocationState {
public:
/// @brief Factory function creating the state instance from subnet.
///
/// @param subnet instance of the subnet for which the allocation
/// state should be instantiated.
/// @return new allocation state instance.
static SubnetIterativeAllocationStatePtr create(const SubnetPtr& subnet);
/// @brief Constructor.
///
/// @param prefix subnet prefix.
/// @param prefix_length subnet prefix length.
SubnetIterativeAllocationState(const asiolink::IOAddress& prefix,
const uint8_t prefix_length);
/// @brief Returns last allocated address or prefix.
///
/// @return last allocated address or prefix.
asiolink::IOAddress getLastAllocated() const;
/// @brief Sets last allocated address or prefix.
///
/// @param address an address or prefix last allocated.
void setLastAllocated(const asiolink::IOAddress& address);
private:
/// @brief Last allocated address or delegated prefix.
///
/// This is the last allocated address or delegated prefix that was
/// previously allocated from the particular subnet. It should be
/// noted that although the value is usually correct, there are
/// cases when it is invalid, e.g. after removing a pool,
/// restarting or changing allocation algorithms. For that purpose
/// it should be only considered a help that should not be fully
/// trusted.
asiolink::IOAddress last_allocated_;
};
/// @brief Forward declaration of the @c PoolIterativeAllocationState.
class PoolIterativeAllocationState;
/// @brief Type of the pointer to the @c PoolIterativeAllocationState.
typedef boost::shared_ptr<PoolIterativeAllocationState> PoolIterativeAllocationStatePtr;
/// @brief Pool allocation state used by the iterative allocator.
///
/// It extends the base class with the information about the last allocated
/// address in the pool.
class PoolIterativeAllocationState : public AllocationState {
public:
/// @brief Factory function creating the state instance from pool.
///
/// @param pool instance of the pool for which the allocation state
/// should be instantiated.
/// @return new allocation state instance.
static PoolIterativeAllocationStatePtr create(const PoolPtr& pool);
/// @brief Constructor.
///
/// @param first first address in the pool.
PoolIterativeAllocationState(const asiolink::IOAddress& first);
/// @brief Returns the last address that was tried from this pool
///
/// @return address or prefix that was last tried from this pool
isc::asiolink::IOAddress getLastAllocated() const {
return (last_allocated_);
}
/// @brief Checks if the last address is valid.
///
/// @return true if the last address is valid, false otherwise.
bool isLastAllocatedValid() const {
return last_allocated_valid_;
}
/// @brief Sets the last address that was tried from this pool.
///
/// @param address address or prefix to that was tried last.
void setLastAllocated(const asiolink::IOAddress& address) {
last_allocated_ = address;
last_allocated_valid_ = true;
}
/// @brief Resets the last address to invalid.
void resetLastAllocated() {
last_allocated_valid_ = false;
}
private:
/// @brief Last allocated address or prefix.
isc::asiolink::IOAddress last_allocated_;
/// @brief Last allocated address status.
bool last_allocated_valid_;
};
} // end of namespace isc::dhcp
} // end of namespace isc
#endif // ITERATIVE_ALLOCATION_STATE_H
Mini Shell