[#1415] Support for PD in free lease container

Author: msiodelski

src/lib/dhcpsrv/address_range.cc

@@ -5,6 +5,7 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <config.h>
+#include <asiolink/addr_utilities.h>
 #include <asiolink/io_address.h>
 #include <dhcpsrv/address_range.h>
 #include <exceptions/exceptions.h>
@@ -27,5 +28,42 @@ AddressRange::AddressRange(const IOAddress& start, const IOAddress& end)
     }
 }
 
+PrefixRange::PrefixRange(const asiolink::IOAddress& prefix, const uint8_t length, const uint8_t delegated)
+    : start_(prefix), end_(IOAddress::IPV6_ZERO_ADDRESS()), delegated_length_(delegated) {
+    if (!start_.isV6()) {
+        isc_throw(BadValue, "IPv6 prefix required for prefix delegation range but "
+                  << start_ << " was specified");
+    }
+    if (delegated_length_ < length) {
+        isc_throw(BadValue, "delegated length " << static_cast<int>(delegated_length_)
+                  << " must not be lower than prefix length " << static_cast<int>(length));
+    }
+    if ((length > 128) || (delegated_length_ > 128)) {
+        isc_throw(BadValue, "delegated length " << static_cast<int>(delegated_length_)
+                  << " and prefix length " << static_cast<int>(length)
+                  << " must not be greater than 128");
+    }
+    auto prefixes_num = prefixesInRange(length, delegated_length_);
+    uint64_t addrs_in_prefix = static_cast<uint64_t>(1) << (128 - delegated_length_);
+    end_ = offsetAddress(prefix, (prefixes_num - 1) * addrs_in_prefix);
+}
+
+PrefixRange::PrefixRange(const asiolink::IOAddress& start, const asiolink::IOAddress& end,
+                         const uint8_t delegated)
+    : start_(start), end_(end), delegated_length_(delegated) {
+    if (!start_.isV6() || !end_.isV6()) {
+        isc_throw(BadValue, "IPv6 prefix required for prefix delegation range but "
+                  << start_ << ":" << end_ << " was specified");
+    }
+    // The start must be lower or equal the end.
+    if (end_ < start_) {
+        isc_throw(BadValue, "invalid address range boundaries " << start_ << ":" << end_);
+    }
+    if (delegated_length_ > 128) {
+        isc_throw(BadValue, "delegated length " << static_cast<int>(delegated_length_)
+                  << " must not be greater than 128");
+    }
+}
+ 
 } // end of namespace isc::dhcp
 } // end of namespace isc

src/lib/dhcpsrv/free_lease_queue.cc

@@ -5,13 +5,12 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <config.h>
+#include <asiolink/addr_utilities.h>
 #include <dhcpsrv/free_lease_queue.h>
-#include <exceptions/exceptions.h>
 
 #include <boost/make_shared.hpp>
 
 #include <iostream>
-#include <iterator>
 #include <tuple>
 #include <utility>
 
@@ -29,48 +28,9 @@ FreeLeaseQueue::addRange(const Range& range) {
     // If the container with ranges is empty, there are is no need for
     // doing any checks. Let's just add the new range.
     if (!containers_.empty()) {
-        // Get the next range in the container relative to the start of the new
-        // range. The upper_bound returns the range which starts after the start
-        // of the new range.
-        auto next_range = containers_.lower_bound(range.start_);
-        // Get the range the range that is before that one. It is also possible that
-        // there is no previous range in which case we default to end().
-        auto previous_range = containers_.end();
-        // If the next range is at the beginning of the container there is no
-        // previous range.
-        if (next_range != containers_.begin()) {
-            // This should work fine even if the next range is set to end(). We
-            // will get the range that is one position before end() and that
-            // should be the range that goes before the new one.
-            auto it = next_range;
-            --it;
-            previous_range = it;
-        }
-
-        // Now that we have next and previous ranges set we should check that the
-        // new range we're adding does not overlap with them.
-
-        // If the previous range exists, let's check that the start of the new
-        // range is neither within that range nor lower. Assuming that the ranges
-        // are constructed such that the end must be greater or equal the start
-        // it is sufficient to check that the start of the new range is not lower
-        // or equal the end of the previous range.
-        if ((previous_range != containers_.end()) &&
-            (range.start_ <= previous_range->range_end_)) {
-            isc_throw(BadValue, "new address range " << range.start_ << ":" << range.end_
-                      << " overlaps with the existing range");
-        }
-
-        // If the next range exists, let's check that the end of the new range
-        // is neither within that range nor higher.
-        if ((next_range != containers_.end()) &&
-            (next_range->range_start_ <= range.end_)) {
-            isc_throw(BadValue, "new address range " << range.start_ << ":" << range.end_
-                      << " overlaps with the existing range");
-        }
-    }
-
-    containers_.insert(ContainerDescriptor{range.start_, range.end_,
+        checkRangeOverlaps(range.start_, range.end_);
+    }
+    containers_.insert(ContainerDescriptor{range.start_, range.end_, 128,
                                            boost::make_shared<Container>()});
 }
 
@@ -79,9 +39,20 @@ FreeLeaseQueue::addRange(const IOAddress& start, const IOAddress& end) {
     addRange(FreeLeaseQueue::Range(start, end));
 }
 
-bool
-FreeLeaseQueue::removeRange(const Range& range) {
-    return (containers_.get<1>().erase(range.start_) > 0);
+void
+FreeLeaseQueue::addRange(const PrefixRange& range) {
+    if (!containers_.empty()) {
+        auto last_addr = offsetAddress(range.end_, range.delegated_length_ - 1);
+        checkRangeOverlaps(range.start_, last_addr);
+    }
+    containers_.insert(ContainerDescriptor{range.start_, range.end_, range.delegated_length_,
+                                           boost::make_shared<Container>()});
+}
+
+void
+FreeLeaseQueue::addRange(const asiolink::IOAddress& prefix, const uint8_t prefix_length,
+                         const uint8_t delegated_length) {
+    addRange(FreeLeaseQueue::PrefixRange(prefix, prefix_length, delegated_length));
 }
 
 bool
@@ -112,33 +83,63 @@ FreeLeaseQueue::append(const IOAddress& address) {
     return (true);
 }
 
+bool
+FreeLeaseQueue::append(const IOAddress& prefix, const uint8_t delegated_length) {
+    // If there are no ranges defined, there is nothing to do.
+    if (containers_.empty()) {
+        return (false);
+    }
+    // Find the beginning of the range which has the start address
+    // greater than the address we're appending.
+    auto lb = containers_.upper_bound(prefix);
+    // If the range we found is the first one in the container
+    // there is no range matching our prefix because all existing
+    // ranges include higher addresses.
+    if (lb == containers_.begin()) {
+        return (false);
+    }
+    --lb;
+    // Go one range back and see if our prefix is within its boundaries.
+    if ((lb->range_end_ < prefix) || (prefix < lb->range_start_) ||
+        (delegated_length != lb->delegated_length_)) {
+        return (false);
+    }
+    // Use the range we found and append the prefix to it.
+    FreeLeaseQueue::PrefixRange range(lb->range_start_, lb->range_end_, lb->delegated_length_);
+    append(range, prefix);
+
+    // Everything is fine.
+    return (true);
+}
+
 void
 FreeLeaseQueue::append(const FreeLeaseQueue::Range& range, const IOAddress& address) {
     // Make sure the address is within the range boundaries.
-    if ((address < range.start_) || (range.end_ < address)) {
-        isc_throw(BadValue, "address " << address << " is not within the range of "
-                  << range.start_ << ":" << range.end_);
-    }
+    checkRangeBoundaries(range, address);
     auto cont = getContainer(range);
     cont->insert(address);
 }
 
 void
-FreeLeaseQueue::append(const uint64_t range_index, const IOAddress& address) {
+FreeLeaseQueue::append(const uint64_t range_index, const IOAddress& ip) {
     auto desc = getContainerDescriptor(range_index);
-    if ((address < desc.range_start_) || (desc.range_end_ < address)) {
-        isc_throw(BadValue, "address " << address << " is not within the range of "
-                  << desc.range_start_ << ":" << desc.range_end_);
+    if ((ip < desc.range_start_) || (desc.range_end_ < ip)) {
+        isc_throw(BadValue, ip << " is not within the range of " << desc.range_start_
+                  << ":" << desc.range_end_);
     }
-    desc.container_->insert(address);
+    desc.container_->insert(ip);
+}
+
+void
+FreeLeaseQueue::append(const FreeLeaseQueue::PrefixRange& range, const asiolink::IOAddress& prefix) {
+    checkRangeBoundaries(range, prefix, true);
+    auto cont = getContainer(range);
+    cont->insert(prefix);
 }
 
 bool
 FreeLeaseQueue::use(const FreeLeaseQueue::Range& range, const IOAddress& address) {
-    if ((address < range.start_) || (range.end_ < address)) {
-        isc_throw(BadValue, "address " << address << " is outside of the range of "
-                  << range.start_ << ":" << range.end_);
-    }
+    checkRangeBoundaries(range, address);
     auto cont = getContainer(range);
     auto found = cont->find(address);
     if (found != cont->end()) {
@@ -148,28 +149,74 @@ FreeLeaseQueue::use(const FreeLeaseQueue::Range& range, const IOAddress& address
     return (false);
 }
 
-IOAddress
-FreeLeaseQueue::next(const FreeLeaseQueue::Range& range) {
-    return (popNextInternal(range, true));
+bool
+FreeLeaseQueue::use(const FreeLeaseQueue::PrefixRange& range, const IOAddress& prefix) {
+    checkRangeBoundaries(range, prefix, true);
+    auto cont = getContainer(range);
+    auto found = cont->find(prefix);
+    if (found != cont->end()) {
+        static_cast<void>(cont->erase(found));
+        return (true);
+    }
+    return (false);
 }
 
-IOAddress
-FreeLeaseQueue::pop(const FreeLeaseQueue::Range& range) {
-    return (popNextInternal(range, false));
+template<typename RangeType>
+void
+FreeLeaseQueue::checkRangeBoundaries(const RangeType& range, const IOAddress& ip,
+                                     const bool prefix) const {
+    if ((ip < range.start_) || (range.end_ < ip)) {
+        isc_throw(BadValue, (prefix ? "prefix " : "address ") << ip << " is not within the range of "
+                  << range.start_ << ":" << range.end_);
+    }
 }
 
-uint64_t
-FreeLeaseQueue::getRangeIndex(const FreeLeaseQueue::Range& range) const {
-    auto cont = containers_.get<1>().find(range.start_);
-    if (cont == containers_.get<1>().end()) {
-        isc_throw(BadValue, "conatiner for the specified address range " << range.start_
-                  << ":" << range.end_ << " does not exist");
+void
+FreeLeaseQueue::checkRangeOverlaps(const IOAddress& start, const IOAddress& end) const {
+    // Get the next range in the container relative to the start of the new
+    // range. The upper_bound returns the range which starts after the start
+    // of the new range.
+    auto next_range = containers_.lower_bound(start);
+    // Get the range the range that is before that one. It is also possible that
+    // there is no previous range in which case we default to end().
+    auto previous_range = containers_.end();
+    // If the next range is at the beginning of the container there is no
+    // previous range.
+    if (next_range != containers_.begin()) {
+        // This should work fine even if the next range is set to end(). We
+        // will get the range that is one position before end() and that
+        // should be the range that goes before the new one.
+        auto it = next_range;
+        --it;
+        previous_range = it;
+    }
+
+    // Now that we have next and previous ranges set we should check that the
+    // new range we're adding does not overlap with them.
+
+    // If the previous range exists, let's check that the start of the new
+    // range is neither within that range nor lower. Assuming that the ranges
+    // are constructed such that the end must be greater or equal the start
+    // it is sufficient to check that the start of the new range is not lower
+    // or equal the end of the previous range.
+    if ((previous_range != containers_.end()) &&
+        (start <= previous_range->range_end_)) {
+        isc_throw(BadValue, "new address range " << start << ":" << end
+                  << " overlaps with the existing range");
+    }
+
+    // If the next range exists, let's check that the end of the new range
+    // is neither within that range nor higher.
+    if ((next_range != containers_.end()) &&
+        (next_range->range_start_ <= end)) {
+        isc_throw(BadValue, "new address range " << start << ":" << end
+                  << " overlaps with the existing range");
     }
-    return (std::distance(containers_.get<2>().begin(), containers_.project<2>(cont)));
 }
 
+
 FreeLeaseQueue::ContainerPtr
-FreeLeaseQueue::getContainer(const FreeLeaseQueue::Range& range) {
+FreeLeaseQueue::getContainer(const FreeLeaseQueue::Range& range) const {
     auto cont = containers_.find(range.start_);
     if (cont == containers_.end()) {
         isc_throw(BadValue, "conatiner for the specified address range " << range.start_
@@ -178,8 +225,19 @@ FreeLeaseQueue::getContainer(const FreeLeaseQueue::Range& range) {
     return (cont->container_);
 }
 
+FreeLeaseQueue::ContainerPtr
+FreeLeaseQueue::getContainer(const FreeLeaseQueue::PrefixRange& range) const {
+    auto cont = containers_.find(range.start_);
+    if (cont == containers_.end()) {
+        isc_throw(BadValue, "conatiner for the specified prefix " << range.start_
+                  << " and delegated length of " << static_cast<int>(range.delegated_length_)
+                  << " does not exist");
+    }
+    return (cont->container_);
+}
+
 FreeLeaseQueue::ContainerDescriptor
-FreeLeaseQueue::getContainerDescriptor(const uint64_t range_index) {
+FreeLeaseQueue::getContainerDescriptor(const uint64_t range_index) const {
     if (containers_.get<2>().size() <= range_index) {
         isc_throw(BadValue, "conatiner for the specified range index " << range_index
                   << " does not exist");
@@ -188,21 +246,5 @@ FreeLeaseQueue::getContainerDescriptor(const uint64_t range_index) {
     return (cont);
 }
 
-IOAddress
-FreeLeaseQueue::popNextInternal(const Range& range, const bool push) {
-    auto cont = getContainer(range);
-    if (cont->empty()) {
-        return (IOAddress::IPV4_ZERO_ADDRESS());
-    }
-    auto& idx = cont->get<1>();
-    auto next = idx.front();
-    idx.pop_front();
-    if (push) {
-        idx.push_back(next);
-    }
-    return (next);
-
-}
-
 } // end of namespace isc::dhcp
 } // end of namespace isc