[#2022] Reorganized v6 code

Author: fxdupont

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);

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,49 +155,48 @@ class Dhcpv6Srv : public process::Daemon {
     /// 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.
     ///
     /// It verifies correctness of the passed packet, calls per-type processXXX
     /// 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.
     ///
     /// @param callout_handle pointer to the callout handle.
     /// @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.
     ///
     /// It verifies correctness of the passed packet, 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 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.
     ///
     /// It calls per-type processXXX methods, generates appropriate answer,
     /// 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 @@ class Dhcpv6Srv : public process::Daemon {
     /// @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 @@ class Dhcpv6Srv : public process::Daemon {
     /// 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);