free_lease_queue.h

Go to the documentation of this file.

// Copyright (C) 2020-2021 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 FREE_LEASE_QUEUE_H
#define FREE_LEASE_QUEUE_H

#include <asiolink/io_address.h>
#include <dhcpsrv/ip_range.h>
#include <exceptions/exceptions.h>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/random_access_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/shared_ptr.hpp>

#include <iterator>
#include <map>

namespace isc {
namespace dhcp {

class FreeLeaseQueue {
public:

    FreeLeaseQueue();

    void addRange(const AddressRange& range);

    void addRange(const asiolink::IOAddress& start, const asiolink::IOAddress& end);

    void addRange(const PrefixRange& range);

    void addRange(const asiolink::IOAddress& prefix, const uint8_t prefix_length,
                  const uint8_t delegated_length);

    template<typename RangeType>
    bool removeRange(const RangeType& range) {
        return (ranges_.get<1>().erase(range.start_) > 0);
    }

    bool append(const asiolink::IOAddress& address);

    bool append(const asiolink::IOAddress& prefix, const uint8_t delegated_length);

    void append(const AddressRange& range, const asiolink::IOAddress& address);

    void append(const PrefixRange& range, const asiolink::IOAddress& prefix);

    void append(const uint64_t range_index, const asiolink::IOAddress& ip);

    bool use(const AddressRange& range, const asiolink::IOAddress& address);

    bool use(const PrefixRange& range, const asiolink::IOAddress& prefix);

    template<typename RangeType>
    asiolink::IOAddress next(const RangeType& range) {
        return (popNextInternal(range, true));
    }

    template<typename RangeType>
    asiolink::IOAddress pop(const RangeType& range) {
        return (popNextInternal(range, false));
    }

    template<typename RangeType>
    uint64_t getRangeIndex(const RangeType& range) const {
        auto cont = ranges_.get<1>().find(range.start_);
        if (cont == ranges_.get<1>().end()) {
            isc_throw(BadValue, "container for the specified range " << range.start_
                      << ":" << range.end_ << " does not exist");
        }
        return (std::distance(ranges_.get<2>().begin(), ranges_.project<2>(cont)));
    }

private:

    typedef boost::multi_index_container<
        isc::asiolink::IOAddress,
        boost::multi_index::indexed_by<
            boost::multi_index::ordered_unique<
                boost::multi_index::identity<asiolink::IOAddress>
                >,
            boost::multi_index::sequenced<>
        >
    > Leases;

    typedef boost::shared_ptr<Leases> LeasesPtr;

    struct RangeDescriptor {
        asiolink::IOAddress range_start_;
        asiolink::IOAddress range_end_;
        uint8_t delegated_length_;
        LeasesPtr leases_;
    };

    typedef boost::multi_index_container<
        RangeDescriptor,
        boost::multi_index::indexed_by<
            boost::multi_index::ordered_unique<
                boost::multi_index::member<RangeDescriptor, asiolink::IOAddress,
                                           &RangeDescriptor::range_start_>
            >,
            boost::multi_index::hashed_unique<
                boost::multi_index::member<RangeDescriptor, asiolink::IOAddress,
                                           &RangeDescriptor::range_start_>
            >,
            boost::multi_index::random_access<>
        >
    > Ranges;

    template<typename RangeType>
    void checkRangeBoundaries(const RangeType& range, const asiolink::IOAddress& ip,
                              const bool prefix = false) const;

    void checkRangeOverlaps(const asiolink::IOAddress& start,
                            const asiolink::IOAddress& end) const;

    LeasesPtr getLeases(const AddressRange& range) const;

    LeasesPtr getLeases(const PrefixRange& range) const;

    RangeDescriptor getRangeDescriptor(const uint64_t range_index) const;

    template<typename RangeType>
    asiolink::IOAddress popNextInternal(const RangeType& range, const bool push) {
        auto cont = getLeases(range);
        if (cont->empty()) {
            return (range.start_.isV4() ? asiolink::IOAddress::IPV4_ZERO_ADDRESS() :
                    asiolink::IOAddress::IPV6_ZERO_ADDRESS());
        }
        auto& idx = cont->template get<1>();
        auto next = idx.front();
        idx.pop_front();
        if (push) {
            idx.push_back(next);
        }
        return (next);
    }

    Ranges ranges_;
};

} // end of namespace isc::dhcp
} // end of namespace isc

#endif // FREE_LEASE_QUEUE_H