[5458] Eliminated extraneous Pkt6Ptr arguments in calls to processX funcs.

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 1fb688ccdf486fc1180c16b6366126c3e140c598..7c9001b78b581ec0762d773e06d00f3e5a0ca683 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -674,35 +674,35 @@ Dhcpv6Srv::processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp) {
     try {
         switch (query->getType()) {
         case DHCPV6_SOLICIT:
-            rsp = processSolicit(query, ctx);
+            rsp = processSolicit(ctx);
             break;
 
         case DHCPV6_REQUEST:
-            rsp = processRequest(query, ctx);
+            rsp = processRequest(ctx);
             break;
 
         case DHCPV6_RENEW:
-            rsp = processRenew(query, ctx);
+            rsp = processRenew(ctx);
             break;
 
         case DHCPV6_REBIND:
-            rsp = processRebind(query, ctx);
+            rsp = processRebind(ctx);
             break;
 
         case DHCPV6_CONFIRM:
-            rsp = processConfirm(query, ctx);
+            rsp = processConfirm(ctx);
             break;
 
         case DHCPV6_RELEASE:
-            rsp = processRelease(query, ctx);
+            rsp = processRelease(ctx);
             break;
 
         case DHCPV6_DECLINE:
-            rsp = processDecline(query, ctx);
+            rsp = processDecline(ctx);
             break;
 
         case DHCPV6_INFORMATION_REQUEST:
-            rsp = processInfRequest(query, ctx);
+            rsp = processInfRequest(ctx);
             break;
 
         default:
@@ -2706,9 +2706,9 @@ Dhcpv6Srv::releaseIA_PD(const DuidPtr& duid, const Pkt6Ptr& query,
 
 
 Pkt6Ptr
-Dhcpv6Srv::processSolicit(const Pkt6Ptr& solicit,
-                          AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processSolicit(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr solicit = ctx.query_;
     Pkt6Ptr response(new Pkt6(DHCPV6_ADVERTISE, solicit->getTransid()));
 
     // Handle Rapid Commit option, if present.
@@ -2751,9 +2751,9 @@ Dhcpv6Srv::processSolicit(const Pkt6Ptr& solicit,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processRequest(const Pkt6Ptr& request,
-                          AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processRequest(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr request = ctx.query_;
     Pkt6Ptr reply(new Pkt6(DHCPV6_REPLY, request->getTransid()));
 
     processClientFqdn(request, reply, ctx);
@@ -2779,9 +2779,9 @@ Dhcpv6Srv::processRequest(const Pkt6Ptr& request,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processRenew(const Pkt6Ptr& renew,
-                        AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processRenew(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr renew = ctx.query_;
     Pkt6Ptr reply(new Pkt6(DHCPV6_REPLY, renew->getTransid()));
 
     processClientFqdn(renew, reply, ctx);
@@ -2807,9 +2807,9 @@ Dhcpv6Srv::processRenew(const Pkt6Ptr& renew,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processRebind(const Pkt6Ptr& rebind,
-                         AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processRebind(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr rebind = ctx.query_;
     Pkt6Ptr reply(new Pkt6(DHCPV6_REPLY, rebind->getTransid()));
 
     processClientFqdn(rebind, reply, ctx);
@@ -2835,9 +2835,9 @@ Dhcpv6Srv::processRebind(const Pkt6Ptr& rebind,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processConfirm(const Pkt6Ptr& confirm,
-                          AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processConfirm(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr confirm = ctx.query_;
     setReservedClientClasses(confirm, ctx);
     requiredClassify(confirm, ctx);
 
@@ -2925,9 +2925,9 @@ Dhcpv6Srv::processConfirm(const Pkt6Ptr& confirm,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processRelease(const Pkt6Ptr& release,
-                          AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processRelease(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr release = ctx.query_;
     setReservedClientClasses(release, ctx);
     requiredClassify(release, ctx);
 
@@ -2953,9 +2953,9 @@ Dhcpv6Srv::processRelease(const Pkt6Ptr& release,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processDecline(const Pkt6Ptr& decline,
-                          AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processDecline(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr decline = ctx.query_;
     setReservedClientClasses(decline, ctx);
     requiredClassify(decline, ctx);
 
@@ -3239,9 +3239,9 @@ Dhcpv6Srv::declineLease(const Pkt6Ptr& decline, const Lease6Ptr lease,
 }
 
 Pkt6Ptr
-Dhcpv6Srv::processInfRequest(const Pkt6Ptr& inf_request,
-                             AllocEngine::ClientContext6& ctx) {
+Dhcpv6Srv::processInfRequest(AllocEngine::ClientContext6& ctx) {
 
+    Pkt6Ptr inf_request = ctx.query_;
     setReservedClientClasses(inf_request, ctx);
     requiredClassify(inf_request, ctx);
 

diff --git a/src/bin/dhcp6/dhcp6_srv.h b/src/bin/dhcp6/dhcp6_srv.h
index 68bdfadae2f7021e8d810f2023aac77f0c9be89c..eab8d76ddf032e77e48b229b593d83f1c5dac7ea 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.h
+++ b/src/bin/dhcp6/dhcp6_srv.h
@@ -226,12 +226,10 @@ protected:
     /// instead of Advertise and requested leases will be assigned
     /// immediately.
     ///
-    /// @param solicit Solicit message received from client
     /// @param ctx Reference to client context
     ///
     /// @return Advertise, Reply message or NULL.
-    Pkt6Ptr processSolicit(const Pkt6Ptr& solicit,
-                           AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processSolicit(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming Request and returns Reply response.
     ///
@@ -241,21 +239,17 @@ protected:
     /// prefixes, respectively. Uses LeaseMgr to allocate or update existing
     /// leases.
     ///
-    /// @param request a message received from client
     /// @param ctx Reference to client context
     ///
     /// @return REPLY message or NULL
-    Pkt6Ptr processRequest(const Pkt6Ptr& request,
-                           AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processRequest(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming Renew message.
     ///
-    /// @param renew message received from the client
     /// @param ctx Reference to client context
     ///
     /// @return Reply message to be sent to the client.
-    Pkt6Ptr processRenew(const Pkt6Ptr& renew,
-                         AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processRenew(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming Rebind message.
     ///
@@ -265,12 +259,10 @@ protected:
     /// client is on the appropriate link or not. We don't seem to do it
     /// now.
     ///
-    /// @param rebind message received from the client.
     /// @param ctx Reference to client context
     ///
     /// @return Reply message to be sent to the client.
-    Pkt6Ptr processRebind(const Pkt6Ptr& rebind,
-                          AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processRebind(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming Confirm message and returns Reply.
     ///
@@ -291,22 +283,18 @@ protected:
     /// code NotOnLink is returned. Otherwise, the Reply message with the
     /// status code Success is returned.
     ///
-    /// @param confirm Confirm message sent by a client.
     /// @param ctx Reference to client context
     ///
     /// @return Reply message from the server or NULL pointer if Confirm
     /// message should be discarded by the server.
-    Pkt6Ptr processConfirm(const Pkt6Ptr& confirm,
-                           AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processConfirm(AllocEngine::ClientContext6& ctx);
 
     /// @brief Process incoming Release message.
     ///
-    /// @param release message received from client
     /// @param ctx Reference to client context
     ///
     /// @return Reply message to be sent to the client.
-    Pkt6Ptr processRelease(const Pkt6Ptr& release,
-                           AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processRelease(AllocEngine::ClientContext6& ctx);
 
     /// @brief Process incoming Decline message.
     ///
@@ -315,21 +303,17 @@ protected:
     /// the client's message. Finally, it calls @ref declineLeases, where
     /// the actual address processing takes place.
     ///
-    /// @param decline message received from client
     /// @param ctx Reference to client context
     ///
     /// @return Reply message to be sent to the client.
-    Pkt6Ptr processDecline(const Pkt6Ptr& decline,
-                           AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processDecline(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming Information-request message.
     ///
-    /// @param inf_request message received from client
     /// @param ctx Reference to client context
     ///
     /// @return Reply message to be sent to the client.
-    Pkt6Ptr processInfRequest(const Pkt6Ptr& inf_request,
-                              AllocEngine::ClientContext6& ctx);
+    Pkt6Ptr processInfRequest(AllocEngine::ClientContext6& ctx);
 
     /// @brief Processes incoming DHCPv4-query message.
     ///

diff --git a/src/bin/dhcp6/tests/classify_unittests.cc b/src/bin/dhcp6/tests/classify_unittests.cc
index 962759bb1bc2b80cc826389d6131d36f387651bb..5a5a6ffd177e594553f80d5bd38eca306cd389ae 100644 (file)
--- a/src/bin/dhcp6/tests/classify_unittests.cc
+++ b/src/bin/dhcp6/tests/classify_unittests.cc
@@ -433,15 +433,15 @@ TEST_F(ClassifyTest, matchClassification) {
     bool drop = false;
     srv.initContext(query1, ctx1, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response1 = srv.processSolicit(query1, ctx1);
+    Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(query2, ctx2, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response2 = srv.processSolicit(query2, ctx2);
+    Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(query3, ctx3, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response3 = srv.processSolicit(query3, ctx3);
+    Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
     // Classification processing should add an ip-forwarding option
     OptionPtr opt1 = response1->getOption(2345);
@@ -536,15 +536,15 @@ TEST_F(ClassifyTest, required) {
     bool drop = false;
     srv.initContext(query1, ctx1, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response1 = srv.processSolicit(query1, ctx1);
+    Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(query2, ctx2, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response2 = srv.processSolicit(query2, ctx2);
+    Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(query3, ctx3, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response3 = srv.processSolicit(query3, ctx3);
+    Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
     // Classification processing should do nothing
     OptionPtr opt1 = response1->getOption(2345);
@@ -636,15 +636,15 @@ TEST_F(ClassifyTest, requiredClassification) {
     bool drop = false;
     srv.initContext(query1, ctx1, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response1 = srv.processSolicit(query1, ctx1);
+    Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(query2, ctx2, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response2 = srv.processSolicit(query2, ctx2);
+    Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(query3, ctx3, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response3 = srv.processSolicit(query3, ctx3);
+    Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
     // Classification processing should add an ip-forwarding option
     OptionPtr opt1 = response1->getOption(2345);
@@ -722,7 +722,7 @@ TEST_F(ClassifyTest, subnetClassPriority) {
     bool drop = false;
     srv.initContext(query, ctx,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response = srv.processSolicit(query, ctx);
+    Pkt6Ptr response = srv.processSolicit(ctx);
 
     // Processing should add an ip-forwarding option
     OptionPtr opt = response->getOption(2345);
@@ -787,7 +787,7 @@ TEST_F(ClassifyTest, subnetGlobalPriority) {
     bool drop = false;
     srv.initContext(query, ctx,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response = srv.processSolicit(query, ctx);
+    Pkt6Ptr response = srv.processSolicit(ctx);
 
     // Processing should add an ip-forwarding option
     OptionPtr opt = response->getOption(2345);
@@ -861,7 +861,7 @@ TEST_F(ClassifyTest, classGlobalPriority) {
     bool drop = false;
     srv.initContext(query, ctx,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response = srv.processSolicit(query, ctx);
+    Pkt6Ptr response = srv.processSolicit(ctx);
 
     // Processing should add an ip-forwarding option
     OptionPtr opt = response->getOption(2345);
@@ -928,7 +928,7 @@ TEST_F(ClassifyTest, classGlobalPersistency) {
     bool drop = false;
     srv.initContext(query, ctx,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response = srv.processSolicit(query, ctx);
+    Pkt6Ptr response = srv.processSolicit(ctx);
 
     // Processing should add an ip-forwarding option
     OptionPtr opt = response->getOption(2345);
@@ -1049,7 +1049,7 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     bool drop = false;
     srv.initContext(query1, ctx1,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response1 = srv.processSolicit(query1, ctx1);
+    Pkt6Ptr response1 = srv.processSolicit(ctx1);
     ASSERT_TRUE(response1);
     OptionPtr ia_na1 = response1->getOption(D6O_IA_NA);
     ASSERT_TRUE(ia_na1);
@@ -1063,7 +1063,7 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(query2, ctx2,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response2 = srv.processSolicit(query2, ctx2);
+    Pkt6Ptr response2 = srv.processSolicit(ctx2);
     ASSERT_TRUE(response2);
     OptionPtr ia_na2 = response2->getOption(D6O_IA_NA);
     ASSERT_TRUE(ia_na2);
@@ -1077,7 +1077,7 @@ TEST_F(ClassifyTest, clientClassifyPool) {
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(query3, ctx3,  drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response3 = srv.processSolicit(query3, ctx3);
+    Pkt6Ptr response3 = srv.processSolicit(ctx3);
     ASSERT_TRUE(response3);
     OptionPtr ia_na3 = response3->getOption(D6O_IA_NA);
     ASSERT_TRUE(ia_na3);
@@ -1366,15 +1366,15 @@ TEST_F(ClassifyTest, member) {
     bool drop = false;
     srv.initContext(query1, ctx1, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response1 = srv.processSolicit(query1, ctx1);
+    Pkt6Ptr response1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(query2, ctx2, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response2 = srv.processSolicit(query2, ctx2);
+    Pkt6Ptr response2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(query3, ctx3, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response3 = srv.processSolicit(query3, ctx3);
+    Pkt6Ptr response3 = srv.processSolicit(ctx3);
 
     // Classification processing should add an ip-forwarding option
     OptionPtr opt1 = response1->getOption(2345);

diff --git a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
index f3893b7099cb2b098377925521aead9fcba47aff..393d1bd4d7648116e6218cce407ffabb0b2b4a85 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
+++ b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
@@ -168,7 +168,7 @@ TEST_F(NakedDhcpv6SrvTest, SolicitNoSubnet) {
     bool drop = false;
     srv.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply = srv.processSolicit(sol, ctx);
+    Pkt6Ptr reply = srv.processSolicit(ctx);
 
     // check that we get the right NAK
     checkNakResponse(reply, DHCPV6_ADVERTISE, 1234, STATUS_NoAddrsAvail,
@@ -393,7 +393,7 @@ TEST_F(Dhcpv6SrvTest, advertiseOptions) {
     bool drop = false;
     srv_.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_.processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_.processSolicit(ctx);
 
     // check if we get response at all
     ASSERT_TRUE(adv);
@@ -420,7 +420,7 @@ TEST_F(Dhcpv6SrvTest, advertiseOptions) {
     AllocEngine::ClientContext6 ctx2;
     srv_.initContext(sol, ctx2, drop);
     ASSERT_FALSE(drop);
-    adv = srv_.processSolicit(sol, ctx2);
+    adv = srv_.processSolicit(ctx2);
     ASSERT_TRUE(adv);
 
     OptionPtr tmp = adv->getOption(D6O_NAME_SERVERS);
@@ -485,7 +485,7 @@ TEST_F(Dhcpv6SrvTest, SolicitBasic) {
     bool drop = false;
     srv.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply = srv.processSolicit(sol, ctx);
+    Pkt6Ptr reply = srv.processSolicit(ctx);
 
     // check if we get response at all
     checkResponse(reply, DHCPV6_ADVERTISE, 1234);
@@ -533,7 +533,7 @@ TEST_F(Dhcpv6SrvTest, pdSolicitBasic) {
     bool drop = false;
     srv.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply = srv.processSolicit(sol, ctx);
+    Pkt6Ptr reply = srv.processSolicit(ctx);
 
     // check if we get response at all
     checkResponse(reply, DHCPV6_ADVERTISE, 1234);
@@ -590,7 +590,7 @@ TEST_F(Dhcpv6SrvTest, SolicitHint) {
     bool drop = false;
     srv.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply = srv.processSolicit(sol, ctx);
+    Pkt6Ptr reply = srv.processSolicit(ctx);
 
     // check if we get response at all
     checkResponse(reply, DHCPV6_ADVERTISE, 1234);
@@ -647,7 +647,7 @@ TEST_F(Dhcpv6SrvTest, SolicitInvalidHint) {
     bool drop = false;
     srv.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply = srv.processSolicit(sol, ctx);
+    Pkt6Ptr reply = srv.processSolicit(ctx);
 
     // check if we get response at all
     checkResponse(reply, DHCPV6_ADVERTISE, 1234);
@@ -709,15 +709,15 @@ TEST_F(Dhcpv6SrvTest, ManySolicits) {
     bool drop = false;
     srv.initContext(sol1, ctx1, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply1 = srv.processSolicit(sol1, ctx1);
+    Pkt6Ptr reply1 = srv.processSolicit(ctx1);
     AllocEngine::ClientContext6 ctx2;
     srv.initContext(sol2, ctx2, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply2 = srv.processSolicit(sol2, ctx2);
+    Pkt6Ptr reply2 = srv.processSolicit(ctx2);
     AllocEngine::ClientContext6 ctx3;
     srv.initContext(sol3, ctx3, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr reply3 = srv.processSolicit(sol3, ctx3);
+    Pkt6Ptr reply3 = srv.processSolicit(ctx3);
 
     // check if we get response at all
     checkResponse(reply1, DHCPV6_ADVERTISE, 1234);
@@ -1726,7 +1726,7 @@ TEST_F(Dhcpv6SrvTest, prlPersistency) {
     bool drop = false;
     srv_.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr response = srv_.processSolicit(sol, ctx);
+    Pkt6Ptr response = srv_.processSolicit(ctx);
 
     // The server should add a subscriber-id option
     ASSERT_TRUE(response->getOption(D6O_SUBSCRIBER_ID));
@@ -1745,7 +1745,7 @@ TEST_F(Dhcpv6SrvTest, prlPersistency) {
     AllocEngine::ClientContext6 ctx2;
     srv_.initContext(sol, ctx2, drop);
     ASSERT_FALSE(drop);
-    response = srv_.processSolicit(sol, ctx2);
+    response = srv_.processSolicit(ctx2);
 
     // Processing should add a subscriber-id option
     ASSERT_TRUE(response->getOption(D6O_SUBSCRIBER_ID));
@@ -1884,7 +1884,7 @@ TEST_F(Dhcpv6SrvTest, vendorOptionsORO) {
     bool drop = false;
     srv_.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_.processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_.processSolicit(ctx);
 
     // check if we get response at all
     ASSERT_TRUE(adv);
@@ -1906,7 +1906,7 @@ TEST_F(Dhcpv6SrvTest, vendorOptionsORO) {
     AllocEngine::ClientContext6 ctx2;
     srv_.initContext(sol, ctx2, drop);
     ASSERT_FALSE(drop);
-    adv = srv_.processSolicit(sol, ctx2);
+    adv = srv_.processSolicit(ctx2);
     ASSERT_TRUE(adv);
 
     // Check if there is vendor option response
@@ -1980,7 +1980,7 @@ TEST_F(Dhcpv6SrvTest, vendorPersistentOptions) {
     bool drop = false;
     srv_.initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_.processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_.processSolicit(ctx);
 
     // check if we get response at all
     ASSERT_TRUE(adv);

diff --git a/src/bin/dhcp6/tests/dhcp6_test_utils.h b/src/bin/dhcp6/tests/dhcp6_test_utils.h
index 6bf4c31a4c80297e76f57a65f40b1f5963c09b1d..da51036bb88f13b58eb1d52d97487a4aaf4804c6 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_test_utils.h
+++ b/src/bin/dhcp6/tests/dhcp6_test_utils.h
@@ -194,7 +194,7 @@ public:
         if (drop) {
             return (Pkt6Ptr());
         }
-        return (processRequest(request, ctx));
+        return (processRequest(ctx));
     }
 
     /// @brief Processes incoming Renew message.
@@ -208,7 +208,7 @@ public:
         if (drop) {
             return (Pkt6Ptr());
         }
-        return (processRenew(renew, ctx));
+        return (processRenew(ctx));
     }
 
     /// @brief Processes incoming Rebind message.
@@ -222,7 +222,7 @@ public:
         if (drop) {
             return (Pkt6Ptr());
         }
-        return (processRebind(rebind, ctx));
+        return (processRebind(ctx));
     }
 
     /// @brief Processes incoming Release message.
@@ -236,7 +236,7 @@ public:
         if (drop) {
             return (Pkt6Ptr());
         }
-        return (processRelease(release, ctx));
+        return (processRelease(ctx));
     }
 
     /// @brief Processes incoming Decline message.
@@ -250,7 +250,7 @@ public:
         if (drop) {
             return (Pkt6Ptr());
         }
-        return (processDecline(decline, ctx));
+        return (processDecline(ctx));
     }
 
     using Dhcpv6Srv::processSolicit;

diff --git a/src/bin/dhcp6/tests/fqdn_unittest.cc b/src/bin/dhcp6/tests/fqdn_unittest.cc
index 98827f71634c205d5003c03358644315a609f39e..9188a5a36cc4a954839b709b6051457c4389d446 100644 (file)
--- a/src/bin/dhcp6/tests/fqdn_unittest.cc
+++ b/src/bin/dhcp6/tests/fqdn_unittest.cc
@@ -499,18 +499,18 @@ public:
         srv_->initContext(req, ctx, drop);
         ASSERT_FALSE(drop);
         if (msg_type == DHCPV6_SOLICIT) {
-          ASSERT_NO_THROW(reply = srv_->processSolicit(req, ctx));
+          ASSERT_NO_THROW(reply = srv_->processSolicit(ctx));
 
         } else if (msg_type == DHCPV6_REQUEST) {
-          ASSERT_NO_THROW(reply = srv_->processRequest(req, ctx));
+          ASSERT_NO_THROW(reply = srv_->processRequest(ctx));
 
         } else if (msg_type == DHCPV6_RENEW) {
-          ASSERT_NO_THROW(reply = srv_->processRenew(req, ctx));
+          ASSERT_NO_THROW(reply = srv_->processRenew(ctx));
 
         } else if (msg_type == DHCPV6_RELEASE) {
             // For Release no lease will be acquired so we have to leave
             // function here.
-          ASSERT_NO_THROW(reply = srv_->processRelease(req, ctx));
+          ASSERT_NO_THROW(reply = srv_->processRelease(ctx));
             return;
         } else {
             // We are not interested in testing other message types.

diff --git a/src/bin/dhcp6/tests/hooks_unittest.cc b/src/bin/dhcp6/tests/hooks_unittest.cc
index 015cd158bc3311ea68e6d964067ea9c0d8bc0416..476d219c0b1428a26acfea7dea67419dbb097dd2 100644 (file)
--- a/src/bin/dhcp6/tests/hooks_unittest.cc
+++ b/src/bin/dhcp6/tests/hooks_unittest.cc
@@ -1597,7 +1597,7 @@ TEST_F(HooksDhcpv6SrvTest, subnet6Select) {
     bool drop = false;
     srv_->initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_->processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_->processSolicit(ctx);
 
     // Check if we get response at all
     ASSERT_TRUE(adv);
@@ -1678,7 +1678,7 @@ TEST_F(HooksDhcpv6SrvTest, subnet6SselectChange) {
     bool drop = false;
     srv_->initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_->processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_->processSolicit(ctx);
 
     // Check if we get response at all
     ASSERT_TRUE(adv);
@@ -3559,7 +3559,7 @@ TEST_F(HooksDhcpv6SrvTest, host6Identifier) {
     bool drop = false;
     srv_->initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_->processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_->processSolicit(ctx);
 
     // Check if we get response at all
     ASSERT_TRUE(adv);
@@ -3636,7 +3636,7 @@ TEST_F(HooksDhcpv6SrvTest, host6Identifier_hwaddr) {
     bool drop = false;
     srv_->initContext(sol, ctx, drop);
     ASSERT_FALSE(drop);
-    Pkt6Ptr adv = srv_->processSolicit(sol, ctx);
+    Pkt6Ptr adv = srv_->processSolicit(ctx);
 
     // Check if we get response at all
     ASSERT_TRUE(adv);