[#2022] Reorganized v6 code

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index ad37414acd5a15dbe0489299232517b59c24b3a2..3a97f51cff630863fd72ecab06827f3e51131515 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -492,20 +492,16 @@ Dhcpv6Srv::earlyGHRLookup(const Pkt6Ptr& query,
 }
 
 void
-Dhcpv6Srv::initContext(const Pkt6Ptr& pkt,
+Dhcpv6Srv::initContext(const Subnet6Ptr& subnet,
+                      const Pkt6Ptr& pkt,
                        AllocEngine::ClientContext6& ctx,
                        bool& drop) {
-    ctx.subnet_ = selectSubnet(pkt, drop);
+    ctx.subnet_ = subnet;
     ctx.fwd_dns_update_ = false;
     ctx.rev_dns_update_ = false;
     ctx.hostname_ = "";
     ctx.callout_handle_ = getCalloutHandle(pkt);
 
-    if (drop) {
-        // Caller will immediately drop the packet so simply return now.
-        return;
-    }
-
     // Collect host identifiers if host reservations enabled. The identifiers
     // are stored in order of preference. The server will use them in that
     // order to search for host reservations.
@@ -703,7 +699,7 @@ Dhcpv6Srv::runOne() {
 }
 
 void
-Dhcpv6Srv::processPacketAndSendResponseNoThrow(Pkt6Ptr& query) {
+Dhcpv6Srv::processPacketAndSendResponseNoThrow(Pkt6Ptr query) {
     try {
         processPacketAndSendResponse(query);
     } catch (const std::exception& e) {
@@ -715,9 +711,8 @@ Dhcpv6Srv::processPacketAndSendResponseNoThrow(Pkt6Ptr& query) {
 }
 
 void
-Dhcpv6Srv::processPacketAndSendResponse(Pkt6Ptr& query) {
-    Pkt6Ptr rsp;
-    processPacket(query, rsp);
+Dhcpv6Srv::processPacketAndSendResponse(Pkt6Ptr query) {
+    Pkt6Ptr rsp = processPacket(query);
     if (!rsp) {
         return;
     }
@@ -726,8 +721,8 @@ Dhcpv6Srv::processPacketAndSendResponse(Pkt6Ptr& query) {
     processPacketBufferSend(callout_handle, rsp);
 }
 
-void
-Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
+Pkt6Ptr
+Dhcpv6Srv::processPacket(Pkt6Ptr query) {
     // All packets belong to ALL.
     query->addClass("ALL");
 
@@ -777,10 +772,14 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
             // Increase the statistic of dropped packets.
             StatsMgr::instance().addValue("pkt6-receive-drop",
                                           static_cast<int64_t>(1));
-            return;
+            return (Pkt6Ptr());
         }
 
         callout_handle->getArgument("query6", query);
+        if (!query) {
+            // Please use the status instead of resetting query!
+            return (Pkt6Ptr());
+        }
     }
 
     // Unpack the packet information unless the buffer6_receive callouts
@@ -812,7 +811,7 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
                                           static_cast<int64_t>(1));
             StatsMgr::instance().addValue("pkt6-receive-drop",
                                           static_cast<int64_t>(1));
-            return;
+            return (Pkt6Ptr());
         }
     }
 
@@ -829,7 +828,7 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
 
         // Increase the statistic of dropped packets.
         StatsMgr::instance().addValue("pkt6-receive-drop", static_cast<int64_t>(1));
-        return;
+        return (Pkt6Ptr());
     }
 
     // Check if the received query has been sent to unicast or multicast.
@@ -839,7 +838,7 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
 
         // Increase the statistic of dropped packets.
         StatsMgr::instance().addValue("pkt6-receive-drop", static_cast<int64_t>(1));
-        return;
+        return (Pkt6Ptr());
     }
 
     // Assign this packet to a class, if possible
@@ -887,15 +886,19 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
             // Increase the statistic of dropped packets.
             StatsMgr::instance().addValue("pkt6-receive-drop",
                                           static_cast<int64_t>(1));
-            return;
+            return (Pkt6Ptr());
         }
 
         callout_handle->getArgument("query6", query);
+        if (!query) {
+            // Please use the status instead of resetting query!
+            return (Pkt6Ptr());
+        }
     }
 
     // Reject the message if it doesn't pass the sanity check.
     if (!sanityCheck(query)) {
-        return;
+        return (Pkt6Ptr());
     }
 
     // Check the DROP special class.
@@ -905,16 +908,16 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
             .arg(query->toText());
         StatsMgr::instance().addValue("pkt6-receive-drop",
                                       static_cast<int64_t>(1));
-        return;
+        return (Pkt6Ptr());
     }
 
-    processDhcp6Query(query, rsp);
+    return (processDhcp6Query(query));
 }
 
 void
-Dhcpv6Srv::processDhcp6QueryAndSendResponse(Pkt6Ptr& query, Pkt6Ptr& rsp) {
+Dhcpv6Srv::processDhcp6QueryAndSendResponse(Pkt6Ptr query) {
     try {
-        processDhcp6Query(query, rsp);
+        Pkt6Ptr rsp = processDhcp6Query(query);
         if (!rsp) {
             return;
         }
@@ -929,8 +932,8 @@ Dhcpv6Srv::processDhcp6QueryAndSendResponse(Pkt6Ptr& query, Pkt6Ptr& rsp) {
     }
 }
 
-void
-Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
+Pkt6Ptr
+Dhcpv6Srv::processDhcp6Query(Pkt6Ptr query) {
     // Create a client race avoidance RAII handler.
     ClientHandler client_handler;
 
@@ -944,36 +947,42 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
          (query->getType() == DHCPV6_DECLINE))) {
         ContinuationPtr cont =
             makeContinuation(std::bind(&Dhcpv6Srv::processDhcp6QueryAndSendResponse,
-                                       this, query, rsp));
+                                       this, query));
         if (!client_handler.tryLock(query, cont)) {
-            return;
+            return (Pkt6Ptr());
         }
     }
 
     // Let's create a simplified client context here.
     AllocEngine::ClientContext6 ctx;
     if (!earlyGHRLookup(query, ctx)) {
-        return;
+        return (Pkt6Ptr());
     }
 
     if (query->getType() == DHCPV6_DHCPV4_QUERY) {
         // This call never throws. Should this change, this section must be
         // enclosed in try-catch.
         processDhcp4Query(query);
-        return;
+        return (Pkt6Ptr());
     }
 
     // Complete the client context initialization.
     bool drop = false;
-    initContext(query, ctx, drop);
-
-    // Stop here if initContext decided to drop the packet.
+    Subnet6Ptr subnet = selectSubnet(query, drop);
     if (drop) {
-        return;
+        // Caller will immediately drop the packet so simply return now.
+        return (Pkt6Ptr());
     }
 
     // Park point here.
 
+    initContext(subnet, query, ctx, drop);
+    // Stop here if initContext decided to drop the packet.
+    if (drop) {
+        return (Pkt6Ptr());
+    }
+
+    Pkt6Ptr rsp;
     try {
         switch (query->getType()) {
         case DHCPV6_SOLICIT:
@@ -1009,7 +1018,7 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
             break;
 
         default:
-            return;
+            return (rsp);
         }
 
     } catch (const std::exception& e) {
@@ -1031,7 +1040,7 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
     }
 
     if (!rsp) {
-        return;
+        return (rsp);
     }
 
     // Process relay-supplied options. It is important to call this very
@@ -1162,7 +1171,7 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
                 isc::stats::StatsMgr::instance().addValue("pkt6-receive-drop",
                                                           static_cast<int64_t>(1));
                 rsp.reset();
-                return;
+                return (rsp);
             }
         }
 
@@ -1219,11 +1228,13 @@ Dhcpv6Srv::processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp) {
     if (rsp) {
         processPacketPktSend(callout_handle, query, rsp);
     }
+
+    return (rsp);
 }
 
 void
 Dhcpv6Srv::sendResponseNoThrow(hooks::CalloutHandlePtr& callout_handle,
-                               Pkt6Ptr& query, Pkt6Ptr& rsp) {
+                               Pkt6Ptr query, Pkt6Ptr& rsp) {
     try {
             processPacketPktSend(callout_handle, query, rsp);
             processPacketBufferSend(callout_handle, rsp);

diff --git a/src/bin/dhcp6/dhcp6_srv.h b/src/bin/dhcp6/dhcp6_srv.h
index e2c255d80950991a673a21cabc4d2b9a89057d3c..e44f4ad6cdccc55febf0c12ef7c9b0b93bdf0155 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.h
+++ b/src/bin/dhcp6/dhcp6_srv.h
@@ -1,4 +1,4 @@
-// Copyright (C) 2011-2022 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-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
@@ -155,7 +155,7 @@ public:
     /// methods, generates appropriate answer, sends the answer to the client.
     ///
     /// @param query A pointer to the packet to be processed.
-    void processPacketAndSendResponse(Pkt6Ptr& query);
+    void processPacketAndSendResponse(Pkt6Ptr query);
 
     /// @brief Process a single incoming DHCPv6 packet and sends the response.
     ///
@@ -163,7 +163,7 @@ public:
     /// methods, generates appropriate answer, sends the answer to the client.
     ///
     /// @param query A pointer to the packet to be processed.
-    void processPacketAndSendResponseNoThrow(Pkt6Ptr& query);
+    void processPacketAndSendResponseNoThrow(Pkt6Ptr query);
 
     /// @brief Process an unparked DHCPv6 packet and sends the response.
     ///
@@ -171,7 +171,7 @@ public:
     /// @param query A pointer to the packet to be processed.
     /// @param rsp A pointer to the response.
     void sendResponseNoThrow(hooks::CalloutHandlePtr& callout_handle,
-                             Pkt6Ptr& query, Pkt6Ptr& rsp);
+                             Pkt6Ptr query, Pkt6Ptr& rsp);
 
     /// @brief Process a single incoming DHCPv6 packet.
     ///
@@ -179,16 +179,16 @@ public:
     /// methods, generates appropriate answer.
     ///
     /// @param query A pointer to the packet to be processed.
-    /// @param rsp A pointer to the response.
-    void processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp);
+    /// @return A pointer to the response.
+    Pkt6Ptr processPacket(Pkt6Ptr query);
 
     /// @brief Process a single incoming DHCPv6 query.
     ///
     /// It calls per-type processXXX methods, generates appropriate answer.
     ///
     /// @param query A pointer to the packet to be processed.
-    /// @param rsp A pointer to the response.
-    void processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp);
+    /// @return A pointer to the response.
+    Pkt6Ptr processDhcp6Query(Pkt6Ptr query);
 
     /// @brief Process a single incoming DHCPv6 query.
     ///
@@ -196,8 +196,7 @@ public:
     /// sends the answer to the client.
     ///
     /// @param query A pointer to the packet to be processed.
-    /// @param rsp A pointer to the response.
-    void processDhcp6QueryAndSendResponse(Pkt6Ptr& query, Pkt6Ptr& rsp);
+    void processDhcp6QueryAndSendResponse(Pkt6Ptr query);
 
     /// @brief Instructs the server to shut down.
     void shutdown() override;
@@ -905,7 +904,6 @@ protected:
     /// @brief Initializes client context for specified packet
     ///
     /// This method:
-    /// - Performs the subnet selection and stores the result in context
     /// - Extracts the duid from the packet and saves it to the context
     /// - Extracts the hardware address from the packet and saves it to
     /// the context
@@ -919,10 +917,12 @@ protected:
     /// the Rapid Commit option was included and that the server respects
     /// it.
     ///
+    /// @param subnet Selected subnet.
     /// @param pkt pointer to a packet for which context will be created.
     /// @param [out] ctx reference to context object to be initialized.
     /// @param [out] drop if it is true the packet will be dropped.
-    void initContext(const Pkt6Ptr& pkt,
+    void initContext(const Subnet6Ptr& subnet,
+                     const Pkt6Ptr& pkt,
                      AllocEngine::ClientContext6& ctx,
                      bool& drop);
 

diff --git a/src/bin/dhcp6/tests/classify_unittests.cc b/src/bin/dhcp6/tests/classify_unittests.cc
index c04c58a94443332c49f03bcd4d151cba704f6c16..6d8c865142b42e1e72b8e5fe44742432638f74fa 100644 (file)
--- a/src/bin/dhcp6/tests/classify_unittests.cc
+++ b/src/bin/dhcp6/tests/classify_unittests.cc
@@ -657,19 +657,25 @@ TEST_F(ClassifyTest, matchClassification) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2, drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(query3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(query3, ctx3, drop);
+    subnet = srv_.selectSubnet(query3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query3, ctx3, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
@@ -769,19 +775,25 @@ TEST_F(ClassifyTest, required) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2, drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(query3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(query3, ctx3, drop);
+    subnet = srv_.selectSubnet(query3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query3, ctx3, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
@@ -878,19 +890,25 @@ TEST_F(ClassifyTest, requiredClassification) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2, drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(query3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(query3, ctx3, drop);
+    subnet = srv_.selectSubnet(query3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query3, ctx3, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
@@ -970,7 +988,9 @@ TEST_F(ClassifyTest, subnetClassPriority) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(query, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(query, ctx,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query, ctx,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv.processSolicit(ctx);
 
@@ -1037,7 +1057,9 @@ TEST_F(ClassifyTest, subnetGlobalPriority) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(query, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(query, ctx,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query, ctx,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv.processSolicit(ctx);
 
@@ -1113,7 +1135,9 @@ TEST_F(ClassifyTest, classGlobalPriority) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(query, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(query, ctx,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query, ctx,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv.processSolicit(ctx);
 
@@ -1184,7 +1208,9 @@ TEST_F(ClassifyTest, classGlobalPersistency) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(query, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(query, ctx,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query, ctx,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv.processSolicit(ctx);
 
@@ -1254,7 +1280,9 @@ TEST_F(ClassifyTest, classNeverSend) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(query, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(query, ctx,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query, ctx,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv.processSolicit(ctx);
 
@@ -1374,7 +1402,9 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1,  drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     ASSERT_TRUE(response1);
@@ -1390,7 +1420,9 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2,  drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     ASSERT_TRUE(response2);
@@ -1406,7 +1438,9 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(query3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(query3, ctx3,  drop);
+    subnet = srv_.selectSubnet(query3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query3, ctx3,  drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response3 = srv.processSolicit(ctx3);
     ASSERT_TRUE(response3);
@@ -1464,7 +1498,9 @@ TEST_F(ClassifyTest, clientClassifyPoolKnown) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     ASSERT_TRUE(response1);
@@ -1494,7 +1530,9 @@ TEST_F(ClassifyTest, clientClassifyPoolKnown) {
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2, drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     ASSERT_TRUE(response2);
@@ -1795,19 +1833,25 @@ TEST_F(ClassifyTest, member) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(query1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(query1, ctx1, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(query1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(query2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(query2, ctx2, drop);
+    subnet = srv_.selectSubnet(query2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(query3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(query3, ctx3, drop);
+    subnet = srv_.selectSubnet(query3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, query3, ctx3, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response3 = srv.processSolicit(ctx3);
 

diff --git a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
index d7135ba4bcf29d481433ea98b69a1a6413bbbd5f..a0bac4688aa8a7ed23f55d6da61e50300d30d60c 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
+++ b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
@@ -399,7 +399,9 @@ TEST_F(NakedDhcpv6SrvTest, SolicitNoSubnet) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -626,7 +628,9 @@ TEST_F(Dhcpv6SrvTest, advertiseOptions) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_.processSolicit(ctx);
 
@@ -655,7 +659,9 @@ TEST_F(Dhcpv6SrvTest, advertiseOptions) {
     AllocEngine::ClientContext6 ctx2;
     drop = !srv_.earlyGHRLookup(sol, ctx2);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx2, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx2, drop);
     ASSERT_FALSE(drop);
     adv = srv_.processSolicit(ctx2);
     ASSERT_TRUE(adv);
@@ -721,7 +727,9 @@ TEST_F(Dhcpv6SrvTest, SolicitBasic) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -770,7 +778,9 @@ TEST_F(Dhcpv6SrvTest, pdSolicitBasic) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -813,7 +823,9 @@ TEST_F(Dhcpv6SrvTest, defaultLifetimeSolicit) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -861,7 +873,9 @@ TEST_F(Dhcpv6SrvTest, hintZeroLifetimeSolicit) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -911,7 +925,9 @@ TEST_F(Dhcpv6SrvTest, hintLifetimeSolicit) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -959,7 +975,9 @@ TEST_F(Dhcpv6SrvTest, minLifetimeSolicit) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1009,7 +1027,9 @@ TEST_F(Dhcpv6SrvTest, maxLifetimeSolicit) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1069,7 +1089,9 @@ TEST_F(Dhcpv6SrvTest, SolicitHint) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1128,7 +1150,9 @@ TEST_F(Dhcpv6SrvTest, SolicitInvalidHint) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1194,19 +1218,25 @@ TEST_F(Dhcpv6SrvTest, ManySolicits) {
     AllocEngine::ClientContext6 ctx1;
     bool drop = !srv.earlyGHRLookup(sol1, ctx1);
     ASSERT_FALSE(drop);
-    srv.initContext(sol1, ctx1, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol1, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol1, ctx1, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     drop = !srv.earlyGHRLookup(sol2, ctx2);
     ASSERT_FALSE(drop);
-    srv.initContext(sol2, ctx2, drop);
+    subnet = srv.selectSubnet(sol2, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol2, ctx2, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     drop = !srv.earlyGHRLookup(sol3, ctx3);
     ASSERT_FALSE(drop);
-    srv.initContext(sol3, ctx3, drop);
+    subnet = srv.selectSubnet(sol3, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol3, ctx3, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply3 = srv.processSolicit(ctx3);
 
@@ -1296,7 +1326,9 @@ TEST_F(Dhcpv6SrvTest, SolicitCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1368,7 +1400,9 @@ TEST_F(Dhcpv6SrvTest, pdSolicitCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processSolicit(ctx);
 
@@ -1663,7 +1697,9 @@ TEST_F(Dhcpv6SrvTest, RequestCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(req, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(req, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(req, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, req, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processRequest(ctx);
 
@@ -1735,7 +1771,9 @@ TEST_F(Dhcpv6SrvTest, pdRequestCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(req, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(req, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(req, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, req, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processRequest(ctx);
 
@@ -1949,7 +1987,9 @@ TEST_F(Dhcpv6SrvTest, RenewCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(req, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(req, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(req, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, req, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processRenew(ctx);
 
@@ -2021,7 +2061,9 @@ TEST_F(Dhcpv6SrvTest, pdRenewCache) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv.earlyGHRLookup(req, ctx);
     ASSERT_FALSE(drop);
-    srv.initContext(req, ctx, drop);
+    Subnet6Ptr subnet = srv.selectSubnet(req, drop);
+    ASSERT_FALSE(drop);
+    srv.initContext(subnet, req, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr reply = srv.processRenew(ctx);
 
@@ -2963,7 +3005,9 @@ TEST_F(Dhcpv6SrvTest, prlPersistency) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv_.processSolicit(ctx);
 
@@ -2984,7 +3028,9 @@ TEST_F(Dhcpv6SrvTest, prlPersistency) {
     AllocEngine::ClientContext6 ctx2;
     drop = !srv_.earlyGHRLookup(sol, ctx2);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx2, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx2, drop);
     ASSERT_FALSE(drop);
     response = srv_.processSolicit(ctx2);
 
@@ -3006,7 +3052,9 @@ TEST_F(Dhcpv6SrvTest, prlPersistency) {
     AllocEngine::ClientContext6 ctx3;
     drop = !srv_.earlyGHRLookup(sol, ctx3);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx3, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx3, drop);
     ASSERT_FALSE(drop);
     response = srv_.processSolicit(ctx3);
 
@@ -3046,7 +3094,9 @@ TEST_F(Dhcpv6SrvTest, neverSend) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr response = srv_.processSolicit(ctx);
 
@@ -3067,7 +3117,9 @@ TEST_F(Dhcpv6SrvTest, neverSend) {
     AllocEngine::ClientContext6 ctx2;
     drop = !srv_.earlyGHRLookup(sol, ctx2);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx2, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx2, drop);
     ASSERT_FALSE(drop);
     response = srv_.processSolicit(ctx2);
 
@@ -3089,7 +3141,9 @@ TEST_F(Dhcpv6SrvTest, neverSend) {
     AllocEngine::ClientContext6 ctx3;
     drop = !srv_.earlyGHRLookup(sol, ctx3);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx3, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx3, drop);
     ASSERT_FALSE(drop);
     response = srv_.processSolicit(ctx3);
 
@@ -3870,7 +3924,9 @@ TEST_F(Dhcpv6SrvTest, calculateTeeTimers) {
             AllocEngine::ClientContext6 ctx;
             bool drop = !srv.earlyGHRLookup(sol, ctx);
             ASSERT_FALSE(drop);
-            srv.initContext(sol, ctx, drop);
+            Subnet6Ptr subnet = srv.selectSubnet(sol, drop);
+            ASSERT_FALSE(drop);
+            srv.initContext(subnet, sol, ctx, drop);
             ASSERT_FALSE(drop);
             Pkt6Ptr reply = srv.processSolicit(ctx);
 

diff --git a/src/bin/dhcp6/tests/dhcp6_test_utils.h b/src/bin/dhcp6/tests/dhcp6_test_utils.h
index 4d156bf58314e87b86da79c30e24f68a70c45484..51965255eb6ed9d0fb1ea8eba69859e572fe99d6 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_test_utils.h
+++ b/src/bin/dhcp6/tests/dhcp6_test_utils.h
@@ -215,7 +215,14 @@ public:
     Pkt6Ptr processSolicit(const Pkt6Ptr& solicit) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(solicit, ctx);
-        initContext(solicit, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(solicit, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, solicit, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }
@@ -229,7 +236,14 @@ public:
     Pkt6Ptr processRequest(const Pkt6Ptr& request) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(request, ctx);
-        initContext(request, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(request, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, request, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }
@@ -243,7 +257,14 @@ public:
     Pkt6Ptr processRenew(const Pkt6Ptr& renew) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(renew, ctx);
-        initContext(renew, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(renew, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, renew, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }
@@ -257,7 +278,14 @@ public:
     Pkt6Ptr processRebind(const Pkt6Ptr& rebind) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(rebind, ctx);
-        initContext(rebind, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(rebind, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, rebind, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }
@@ -271,7 +299,14 @@ public:
     Pkt6Ptr processRelease(const Pkt6Ptr& release) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(release, ctx);
-        initContext(release, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(release, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, release, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }
@@ -285,7 +320,14 @@ public:
     Pkt6Ptr processDecline(const Pkt6Ptr& decline) {
         AllocEngine::ClientContext6 ctx;
         bool drop = !earlyGHRLookup(decline, ctx);
-        initContext(decline, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        Subnet6Ptr subnet = selectSubnet(decline, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
+        initContext(subnet, decline, ctx, drop);
         if (drop) {
             return (Pkt6Ptr());
         }

diff --git a/src/bin/dhcp6/tests/fqdn_unittest.cc b/src/bin/dhcp6/tests/fqdn_unittest.cc
index 918faceac9d10683486d78aea8ff28241d8cfe56..18054a4d0b96b762c5ea6c74ce02613fc089afde 100644 (file)
--- a/src/bin/dhcp6/tests/fqdn_unittest.cc
+++ b/src/bin/dhcp6/tests/fqdn_unittest.cc
@@ -458,7 +458,9 @@ public:
         AllocEngine::ClientContext6 ctx;
         bool drop = !srv_->earlyGHRLookup(query, ctx);
         ASSERT_FALSE(drop);
-        srv_->initContext(query, ctx, drop);
+        Subnet6Ptr subnet = srv_->selectSubnet(query, drop);
+        ASSERT_FALSE(drop);
+        srv_->initContext(subnet, query, ctx, drop);
 
         ASSERT_FALSE(drop);
         Pkt6Ptr answer = generateMessageWithIds(DHCPV6_ADVERTISE);
@@ -520,7 +522,9 @@ public:
         AllocEngine::ClientContext6 ctx;
         bool drop = !srv_->earlyGHRLookup(req, ctx);
         ASSERT_FALSE(drop);
-        srv_->initContext(req, ctx, drop);
+        Subnet6Ptr subnet = srv_->selectSubnet(req, drop);
+        ASSERT_FALSE(drop);
+        srv_->initContext(subnet, req, ctx, drop);
 
         ASSERT_FALSE(drop);
         if (msg_type == DHCPV6_SOLICIT) {

diff --git a/src/bin/dhcp6/tests/hooks_unittest.cc b/src/bin/dhcp6/tests/hooks_unittest.cc
index 263ead35ddcbb42d41b3b0c22d96d319336a493e..b8fed7db3f5ff13625af24828bf5bd1a6414c211 100644 (file)
--- a/src/bin/dhcp6/tests/hooks_unittest.cc
+++ b/src/bin/dhcp6/tests/hooks_unittest.cc
@@ -1745,7 +1745,9 @@ TEST_F(HooksDhcpv6SrvTest, subnet6SelectSimple) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_->earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_->initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_->selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_->initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_->processSolicit(ctx);
 
@@ -1834,7 +1836,9 @@ TEST_F(HooksDhcpv6SrvTest, subnet6SelectChange) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_->earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_->initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_->selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_->initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_->processSolicit(ctx);
 
@@ -1859,10 +1863,10 @@ TEST_F(HooksDhcpv6SrvTest, subnet6SelectChange) {
 
     // Advertised address must belong to the second pool (in subnet's range,
     // in dynamic pool)
-    auto subnet = subnets->begin();
-    ++subnet;
-    EXPECT_TRUE((*subnet)->inRange(addr_opt->getAddress()));
-    EXPECT_TRUE((*subnet)->inPool(Lease::TYPE_NA, addr_opt->getAddress()));
+    auto subnet6 = subnets->begin();
+    ++subnet6;
+    EXPECT_TRUE((*subnet6)->inRange(addr_opt->getAddress()));
+    EXPECT_TRUE((*subnet6)->inPool(Lease::TYPE_NA, addr_opt->getAddress()));
 
     // Check if the callout handle state was reset after the callout.
     checkCalloutHandleReset(sol);
@@ -5391,7 +5395,9 @@ TEST_F(HooksDhcpv6SrvTest, host6Identifier) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_->earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_->initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_->selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_->initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_->processSolicit(ctx);
 
@@ -5475,7 +5481,9 @@ TEST_F(HooksDhcpv6SrvTest, host6IdentifierHWAddr) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_->earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_->initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_->selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_->initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_->processSolicit(ctx);
 

diff --git a/src/bin/dhcp6/tests/vendor_opts_unittest.cc b/src/bin/dhcp6/tests/vendor_opts_unittest.cc
index 031b6e6fe58dc130e0ebc4c839cfe03f5aed0644..664e5e1d209a675f73207ae6b1f49fd2bae4128e 100644 (file)
--- a/src/bin/dhcp6/tests/vendor_opts_unittest.cc
+++ b/src/bin/dhcp6/tests/vendor_opts_unittest.cc
@@ -178,7 +178,9 @@ public:
         AllocEngine::ClientContext6 ctx;
         bool drop = !srv_.earlyGHRLookup(sol, ctx);
         ASSERT_FALSE(drop);
-        srv_.initContext(sol, ctx, drop);
+        Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+        ASSERT_FALSE(drop);
+        srv_.initContext(subnet, sol, ctx, drop);
         ASSERT_FALSE(drop);
         Pkt6Ptr adv = srv_.processSolicit(ctx);
 
@@ -206,7 +208,9 @@ public:
         AllocEngine::ClientContext6 ctx2;
         drop = !srv_.earlyGHRLookup(sol, ctx2);
         ASSERT_FALSE(drop);
-        srv_.initContext(sol, ctx2, drop);
+        subnet = srv_.selectSubnet(sol, drop);
+        ASSERT_FALSE(drop);
+        srv_.initContext(subnet, sol, ctx2, drop);
         ASSERT_FALSE(drop);
         adv = srv_.processSolicit(ctx2);
         ASSERT_TRUE(adv);
@@ -444,7 +448,9 @@ public:
         AllocEngine::ClientContext6 ctx;
         bool drop = !srv_.earlyGHRLookup(sol, ctx);
         ASSERT_FALSE(drop);
-        srv_.initContext(sol, ctx, drop);
+        Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+        ASSERT_FALSE(drop);
+        srv_.initContext(subnet, sol, ctx, drop);
         ASSERT_FALSE(drop);
         Pkt6Ptr adv = srv_.processSolicit(ctx);
 
@@ -680,7 +686,9 @@ public:
         AllocEngine::ClientContext6 ctx;
         bool drop = !srv_.earlyGHRLookup(sol, ctx);
         ASSERT_FALSE(drop);
-        srv_.initContext(sol, ctx, drop);
+        Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+        ASSERT_FALSE(drop);
+        srv_.initContext(subnet, sol, ctx, drop);
         ASSERT_FALSE(drop);
         Pkt6Ptr adv = srv_.processSolicit(ctx);
 
@@ -1383,7 +1391,9 @@ TEST_F(VendorOptsTest, vendorNeverSend) {
     AllocEngine::ClientContext6 ctx;
     bool drop = !srv_.earlyGHRLookup(sol, ctx);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx, drop);
+    Subnet6Ptr subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx, drop);
     ASSERT_FALSE(drop);
     Pkt6Ptr adv = srv_.processSolicit(ctx);
 
@@ -1407,7 +1417,9 @@ TEST_F(VendorOptsTest, vendorNeverSend) {
     AllocEngine::ClientContext6 ctx3;
     drop = !srv_.earlyGHRLookup(sol, ctx3);
     ASSERT_FALSE(drop);
-    srv_.initContext(sol, ctx3, drop);
+    subnet = srv_.selectSubnet(sol, drop);
+    ASSERT_FALSE(drop);
+    srv_.initContext(subnet, sol, ctx3, drop);
     ASSERT_FALSE(drop);
     adv = srv_.processSolicit(ctx3);
     ASSERT_TRUE(adv);