[#2755] Code done, doc to update

diff --git a/src/bin/dhcp4/dhcp4_srv.cc b/src/bin/dhcp4/dhcp4_srv.cc
index dbbc728327925b291902cda665b78fc6441be2c0..664a0ecdbc2bcdeae5b3dcaf2db3dc14333b6a79 100644 (file)
--- a/src/bin/dhcp4/dhcp4_srv.cc
+++ b/src/bin/dhcp4/dhcp4_srv.cc
@@ -4392,16 +4392,8 @@ Dhcpv4Srv::recoverStashedAgentOption(const Pkt4Ptr& query) {
     }
     vector<uint8_t> rai_data;
     str::decodeFormattedHexString(rai_hex, rai_data);
-    static OptionDefinitionPtr rai_def;
-    if (!rai_def) {
-        rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                        DHO_DHCP_AGENT_OPTIONS);
-    }
-    if (!rai_def) {
-        // Should not happen.
-        return;
-    }
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4, rai_data));
+    static const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4, rai_data));
     // unpackOptions is a bit too flexible so check if it got something...
     if (!rai || rai->getOptions().empty()) {
         return;

diff --git a/src/bin/dhcp4/tests/dhcp4_srv_unittest.cc b/src/bin/dhcp4/tests/dhcp4_srv_unittest.cc
index b97776e72ee6d6f822cfcbc82ac5d3da3c7538b0..a044fadabb1269dfb1bccb65cf296a0d09781dbc 100644 (file)
--- a/src/bin/dhcp4/tests/dhcp4_srv_unittest.cc
+++ b/src/bin/dhcp4/tests/dhcp4_srv_unittest.cc
@@ -304,10 +304,8 @@ TEST_F(Dhcpv4SrvTest, adjustIfaceDataRelayPort) {
     req->setRemotePort(1234);
 
     // Add a RAI relay-port sub-option (the only difference with the previous test).
-    OptionDefinitionPtr rai_def =
-        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
     ASSERT_TRUE(rai);
     req->addOption(rai);
     OptionPtr relay_port(new Option(Option::V4, RAI_OPTION_RELAY_PORT));
@@ -880,10 +878,8 @@ TEST_F(Dhcpv4SrvTest, initResponse) {
     // client-id echo is optional
     // rai echo is done in relayAgentInfoEcho
     // Do subnet selection option
-    OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_SUBNET_SELECTION);
-    ASSERT_TRUE(sbnsel_def);
-    OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4));
+    const OptionDefinition& sbnsel_def = LibDHCP::DHO_SUBNET_SELECTION_DEF();
+    OptionCustomPtr sbnsel(new OptionCustom(sbnsel_def, Option::V4));
     ASSERT_TRUE(sbnsel);
     sbnsel->writeAddress(IOAddress("192.0.2.3"));
     query->addOption(sbnsel);
@@ -1081,11 +1077,9 @@ TEST_F(Dhcpv4SrvTest, sanityCheckDiscover) {
     ASSERT_NO_THROW(srv.processDiscover(pkt));
 
     // Now let's add a server-id. This should throw.
-    OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                              DHO_DHCP_SERVER_IDENTIFIER);
-    ASSERT_TRUE(server_id_def);
+    const OptionDefinition& server_id_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
 
-    OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4));
+    OptionCustomPtr server_id(new OptionCustom(server_id_def, Option::V4));
     server_id->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(server_id);
     EXPECT_THROW_MSG(srv.processDiscover(pkt), RFCViolation,
@@ -1113,10 +1107,8 @@ TEST_F(Dhcpv4SrvTest, sanityCheckRequest) {
     EXPECT_NO_THROW(srv.processRequest(pkt));
 
     // Now let's add a requested address. This should not throw.
-    OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                             DHO_DHCP_REQUESTED_ADDRESS);
-    ASSERT_TRUE(req_addr_def);
-    OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4));
+    const OptionDefinition& req_addr_def = LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF();
+    OptionCustomPtr req_addr(new OptionCustom(req_addr_def, Option::V4));
     req_addr->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(req_addr);
     ASSERT_NO_THROW(srv.processRequest(pkt));
@@ -1128,11 +1120,9 @@ TEST_F(Dhcpv4SrvTest, sanityCheckRequest) {
     ASSERT_NO_THROW(srv.processRequest(pkt));
 
     // Now let's add a server-id. This should not throw.
-    OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                              DHO_DHCP_SERVER_IDENTIFIER);
-    ASSERT_TRUE(server_id_def);
+    const OptionDefinition& server_id_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
 
-    OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4));
+    OptionCustomPtr server_id(new OptionCustom(server_id_def, Option::V4));
     server_id->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(server_id);
     EXPECT_NO_THROW(srv.processRequest(pkt));
@@ -1160,10 +1150,8 @@ TEST_F(Dhcpv4SrvTest, sanityCheckDecline) {
                     " sent from [hwtype=1 00:fe:fe:fe:fe:fe], cid=[no info], tid=0x4d2");
 
     // Now let's add a requested address. This should not throw.
-    OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                             DHO_DHCP_REQUESTED_ADDRESS);
-    ASSERT_TRUE(req_addr_def);
-    OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4));
+    const OptionDefinition& req_addr_def = LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF();
+    OptionCustomPtr req_addr(new OptionCustom(req_addr_def, Option::V4));
     req_addr->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(req_addr);
     ASSERT_NO_THROW(srv.processDecline(pkt));
@@ -1175,11 +1163,9 @@ TEST_F(Dhcpv4SrvTest, sanityCheckDecline) {
     ASSERT_NO_THROW(srv.processDecline(pkt));
 
     // Now let's add a server-id. This should not throw.
-    OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                              DHO_DHCP_SERVER_IDENTIFIER);
-    ASSERT_TRUE(server_id_def);
+    const OptionDefinition& server_id_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
 
-    OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4));
+    OptionCustomPtr server_id(new OptionCustom(server_id_def, Option::V4));
     server_id->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(server_id);
     EXPECT_NO_THROW(srv.processDecline(pkt));
@@ -1209,11 +1195,9 @@ TEST_F(Dhcpv4SrvTest, sanityCheckRelease) {
     ASSERT_NO_THROW(srv.processRelease(pkt));
 
     // Now let's add a server-id. This should not throw.
-    OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                              DHO_DHCP_SERVER_IDENTIFIER);
-    ASSERT_TRUE(server_id_def);
+    const OptionDefinition& server_id_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
 
-    OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4));
+    OptionCustomPtr server_id(new OptionCustom(server_id_def, Option::V4));
     server_id->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(server_id);
     EXPECT_NO_THROW(srv.processRelease(pkt));
@@ -1239,10 +1223,8 @@ TEST_F(Dhcpv4SrvTest, sanityCheckInform) {
     ASSERT_NO_THROW(srv.processInform(pkt));
 
     // Now let's add a requested address. This should not throw.
-    OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                             DHO_DHCP_REQUESTED_ADDRESS);
-    ASSERT_TRUE(req_addr_def);
-    OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4));
+    const OptionDefinition& req_addr_def = LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF();
+    OptionCustomPtr req_addr(new OptionCustom(req_addr_def, Option::V4));
     req_addr->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(req_addr);
     ASSERT_NO_THROW(srv.processInform(pkt));
@@ -1254,11 +1236,9 @@ TEST_F(Dhcpv4SrvTest, sanityCheckInform) {
     ASSERT_NO_THROW(srv.processInform(pkt));
 
     // Now let's add a server-id. This should not throw.
-    OptionDefinitionPtr server_id_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                              DHO_DHCP_SERVER_IDENTIFIER);
-    ASSERT_TRUE(server_id_def);
+    const OptionDefinition& server_id_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
 
-    OptionCustomPtr server_id(new OptionCustom(*server_id_def, Option::V4));
+    OptionCustomPtr server_id(new OptionCustom(server_id_def, Option::V4));
     server_id->writeAddress(IOAddress("192.0.2.3"));
     pkt->addOption(server_id);
     EXPECT_NO_THROW(srv.processInform(pkt));
@@ -2643,13 +2623,11 @@ TEST_F(Dhcpv4SrvTest, acceptServerId) {
     // Remove the server identifier.
     ASSERT_NO_THROW(pkt->delOption(DHO_DHCP_SERVER_IDENTIFIER));
 
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     OptionBuffer override_server_id_buf(IOAddress("10.0.0.128").toBytes());
 
     // Create RAI option.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
     OptionPtr rai_override_server_id(new Option(Option::V4,
                                                 RAI_OPTION_SERVER_ID_OVERRIDE,
                                                 override_server_id_buf));
@@ -4487,10 +4465,8 @@ TEST_F(Dhcpv4SrvTest, relayLinkSelect) {
     dis->addOption(clientid);
 
     // Let's create a Relay Agent Information option
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
     ASSERT_TRUE(rai);
     IOAddress addr("192.0.3.2");
     OptionPtr ols(new Option(Option::V4,
@@ -4518,10 +4494,8 @@ TEST_F(Dhcpv4SrvTest, relayLinkSelect) {
     EXPECT_FALSE(drop);
 
     // Subnet select option has a lower precedence
-    OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_SUBNET_SELECTION);
-    ASSERT_TRUE(sbnsel_def);
-    OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4));
+    const OptionDefinition& sbnsel_def = LibDHCP::DHO_SUBNET_SELECTION_DEF();
+    OptionCustomPtr sbnsel(new OptionCustom(sbnsel_def, Option::V4));
     ASSERT_TRUE(sbnsel);
     sbnsel->writeAddress(IOAddress("192.0.2.3"));
     dis->addOption(sbnsel);
@@ -4622,10 +4596,8 @@ TEST_F(Dhcpv4SrvTest, relayIgnoreLinkSelect) {
     dis->addOption(clientid);
 
     // Let's create a Relay Agent Information option
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
     ASSERT_TRUE(rai);
     IOAddress addr("192.0.3.2");
     OptionPtr ols(new Option(Option::V4,
@@ -4655,10 +4627,8 @@ TEST_F(Dhcpv4SrvTest, relayIgnoreLinkSelect) {
 
     // Subnet select option has a lower precedence, but will succeed
     // because RAI link selection suboptions are being ignored
-    OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_SUBNET_SELECTION);
-    ASSERT_TRUE(sbnsel_def);
-    OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4));
+    const OptionDefinition& sbnsel_def = LibDHCP::DHO_SUBNET_SELECTION_DEF();
+    OptionCustomPtr sbnsel(new OptionCustom(sbnsel_def, Option::V4));
     ASSERT_TRUE(sbnsel);
     sbnsel->writeAddress(IOAddress("192.0.2.3"));
     dis->addOption(sbnsel);
@@ -4758,10 +4728,8 @@ TEST_F(Dhcpv4SrvTest, subnetSelect) {
     dis->addOption(clientid);
 
     // Let's create a Subnet Selection option
-    OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_SUBNET_SELECTION);
-    ASSERT_TRUE(sbnsel_def);
-    OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4));
+    const OptionDefinition& sbnsel_def = LibDHCP::DHO_SUBNET_SELECTION_DEF();
+    OptionCustomPtr sbnsel(new OptionCustom(sbnsel_def, Option::V4));
     ASSERT_TRUE(sbnsel);
     sbnsel->writeAddress(IOAddress("192.0.3.2"));
 
@@ -5258,10 +5226,8 @@ public:
         query_->setHWAddr(hwaddr_);
         query_->setCiaddr(addr_);
 
-        if (!rai_def_) {
-            isc_throw(Unexpected, "RAI definition can't be found");
-        }
-        rai_.reset(new OptionCustom(*rai_def_, Option::V4));
+        rai_.reset(new OptionCustom(LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF(),
+                                    Option::V4));
         rai_sub_.reset(new Option(Option::V4, RAI_OPTION_LINK_SELECTION,
                                   addr_.toBytes()));
         rai_->addOption(rai_sub_);
@@ -5290,9 +5256,6 @@ public:
         LeaseMgrFactory::destroy();
     }
 
-    /// @brief RAI definition.
-    static OptionDefinitionPtr rai_def_;
-
     /// @brief Client address.
     IOAddress addr_;
 
@@ -5324,15 +5287,6 @@ public:
     ElementPtr sub_options_;
 };
 
-OptionDefinitionPtr
-StashAgentOptionTest::rai_def_ = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                       DHO_DHCP_AGENT_OPTIONS);
-
-// Verify that RAI has a definition and can be built.
-TEST(StashAgentOptionTestTest, checkRAI) {
-    ASSERT_TRUE(StashAgentOptionTest::rai_def_);
-}
-
 // Verify the basic positive case.
 TEST_F(StashAgentOptionTest, basic) {
     CfgMgr::instance().commit();
@@ -5398,7 +5352,7 @@ TEST_F(StashAgentOptionTest, oldExtendedInfo) {
 // Verify that empty RAI is supported.
 TEST_F(StashAgentOptionTest, emptyRelayAgentInfo) {
     // Add an empty RAI.
-    OptionPtr empty_rai(new OptionCustom(*StashAgentOptionTest::rai_def_,
+    OptionPtr empty_rai(new OptionCustom(LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF(),
                                          Option::V4));
     query_->addOption(empty_rai);
 

diff --git a/src/bin/dhcp4/tests/dhcp4_test_utils.cc b/src/bin/dhcp4/tests/dhcp4_test_utils.cc
index 94dfe6f48f92109d155258bd839f876e0849a1ea..8f303b9d3d215bdfafe79cd48820a634c77bb98b 100644 (file)
--- a/src/bin/dhcp4/tests/dhcp4_test_utils.cc
+++ b/src/bin/dhcp4/tests/dhcp4_test_utils.cc
@@ -407,17 +407,15 @@ Dhcpv4SrvTest::generateHWAddr(size_t size /*= 6*/) {
 
 OptionCustomPtr
 Dhcpv4SrvTest::makeServerIdOption(const IOAddress& address) {
-    OptionDefinitionPtr option_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_DHCP_SERVER_IDENTIFIER);
-    OptionCustomPtr server_id(new OptionCustom(*option_def, Option::V4));
+    const OptionDefinition& option_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
+    OptionCustomPtr server_id(new OptionCustom(option_def, Option::V4));
     server_id->writeAddress(address);
     return (server_id);
 }
 
 OptionPtr
 Dhcpv4SrvTest::makeFqdnListOption() {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DOMAIN_SEARCH);
+    const OptionDefinition& def = LibDHCP::DHO_DOMAIN_SEARCH_DEF();
 
     // Prepare buffer holding an array of FQDNs.
     const uint8_t fqdn[] = {
@@ -430,8 +428,8 @@ Dhcpv4SrvTest::makeFqdnListOption() {
     // Initialize a vector with the FQDN data.
     std::vector<uint8_t> fqdn_buf(fqdn, fqdn + sizeof(fqdn));
 
-    OptionPtr option = def->optionFactory(Option::V4, DHO_DOMAIN_SEARCH,
-                                          fqdn_buf.begin(), fqdn_buf.end());
+    OptionPtr option = def.optionFactory(Option::V4, DHO_DOMAIN_SEARCH,
+                                         fqdn_buf.begin(), fqdn_buf.end());
 
     return (option);
 }
@@ -784,18 +782,12 @@ Dhcpv4SrvTest::buildCfgOptionTest(IOAddress expected_server_id,
                                   Pkt4Ptr& query,
                                   IOAddress requested,
                                   IOAddress server_id) {
-    OptionDefinitionPtr req_addr_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                             DHO_DHCP_REQUESTED_ADDRESS);
-    ASSERT_TRUE(req_addr_def);
-
-    OptionDefinitionPtr sbnsel_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_SUBNET_SELECTION);
-    ASSERT_TRUE(sbnsel_def);
-
-    OptionCustomPtr req_addr(new OptionCustom(*req_addr_def, Option::V4));
+    const OptionDefinition& req_addr_def = LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF();
+    OptionCustomPtr req_addr(new OptionCustom(req_addr_def, Option::V4));
     req_addr->writeAddress(requested);
 
-    OptionCustomPtr sbnsel(new OptionCustom(*sbnsel_def, Option::V4));
+    const OptionDefinition& sbnsel_def = LibDHCP::DHO_SUBNET_SELECTION_DEF();
+    OptionCustomPtr sbnsel(new OptionCustom(sbnsel_def, Option::V4));
     sbnsel->writeAddress(requested);
 
     query->addOption(req_addr);

diff --git a/src/bin/dhcp4/tests/inform_unittest.cc b/src/bin/dhcp4/tests/inform_unittest.cc
index a91e45d70ce9f1be5aaa333679c8c5f363dcd896..88e80a33e18ef79769ae067431f8ea3180682636 100644 (file)
--- a/src/bin/dhcp4/tests/inform_unittest.cc
+++ b/src/bin/dhcp4/tests/inform_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (C) 2014-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2014-2024 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
@@ -503,11 +503,9 @@ TEST_F(InformTest, messageFieldsLongOptions) {
     // Client requests big option.
     client.requestOption(240);
     // Client also sends multiple options with the same code.
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
     for (uint8_t i = 0; i < 4; ++i) {
         // Create a buffer holding some binary data. This data will be
         // used as reference when we read back the data from a created

diff --git a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
index 1f790c4deaf1091cbcded675d99a87e4a3a10b5f..ca73c0e4f03d079b02a538374ca8c9eb000c6ad7 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
+++ b/src/bin/dhcp6/tests/dhcp6_srv_unittest.cc
@@ -3288,11 +3288,8 @@ TEST_F(Dhcpv6SrvTest, relayOverride) {
 /// @param payload specified payload (0 = fill payload with repeating option code)
 /// @return RSOO with nested options
 OptionPtr createRSOO(const std::vector<uint16_t>& codes, uint8_t payload = 0) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_RSOO);
-    if (!def) {
-        isc_throw(BadValue, "Can't find RSOO definition");
-    }
-    OptionPtr rsoo_container(new OptionCustom(*def, Option::V6));
+    const OptionDefinition& def = LibDHCP::D6O_RSOO_DEF();
+    OptionPtr rsoo_container(new OptionCustom(def, Option::V6));
 
     for (size_t i = 0; i < codes.size(); ++i) {
         OptionBuffer buf(10, payload ? payload : codes[i]); // let's make the option 10 bytes long

diff --git a/src/hooks/dhcp/flex_option/tests/flex_option_unittests.cc b/src/hooks/dhcp/flex_option/tests/flex_option_unittests.cc
index c5149ba5273f5e7c486472687e9bfaad29fa78b3..169d8ba3eed6cc0a836f88f46a926958d611e1ec 100644 (file)
--- a/src/hooks/dhcp/flex_option/tests/flex_option_unittests.cc
+++ b/src/hooks/dhcp/flex_option/tests/flex_option_unittests.cc
@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2022 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2019-2024 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
@@ -1437,8 +1437,8 @@ TEST_F(FlexOptionTest, processFullAddWithComplexString) {
 
     Pkt6Ptr query(new Pkt6(DHCPV6_SOLICIT, 12345));
     Pkt6Ptr response(new Pkt6(DHCPV6_ADVERTISE, 12345));
-    OptionDefinitionPtr def = isc::dhcp::LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_FQDN);
-    OptionCustomPtr str(new OptionCustom(*def, Option::V6));
+    const OptionDefinition& def = LibDHCP::D6O_CLIENT_FQDN_DEF();
+    OptionCustomPtr str(new OptionCustom(def, Option::V6));
     query->addOption(str);
     EXPECT_FALSE(response->getOption(D6O_NEW_POSIX_TIMEZONE));
 
@@ -1472,8 +1472,8 @@ TEST_F(FlexOptionTest, processFullSupersedeWithComplexString) {
 
     Pkt6Ptr query(new Pkt6(DHCPV6_SOLICIT, 12345));
     Pkt6Ptr response(new Pkt6(DHCPV6_ADVERTISE, 12345));
-    OptionDefinitionPtr def = isc::dhcp::LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_FQDN);
-    OptionCustomPtr str(new OptionCustom(*def, Option::V6));
+    const OptionDefinition& def = LibDHCP::D6O_CLIENT_FQDN_DEF();
+    OptionCustomPtr str(new OptionCustom(def, Option::V6));
     query->addOption(str);
     EXPECT_FALSE(response->getOption(D6O_NEW_POSIX_TIMEZONE));
 

diff --git a/src/hooks/dhcp/run_script/tests/run_script_unittests.cc b/src/hooks/dhcp/run_script/tests/run_script_unittests.cc
index 0b6d9203e20861078929165183f01d1790568022..1ada762b60b7eb7559e7c1f3790b1b3651956538 100644 (file)
--- a/src/hooks/dhcp/run_script/tests/run_script_unittests.cc
+++ b/src/hooks/dhcp/run_script/tests/run_script_unittests.cc
@@ -247,10 +247,8 @@ generatePkt4() {
     pkt4->setLocalHWAddr(generateHWAddr());
     pkt4->setRemoteHWAddr(generateHWAddr());
 
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     uint8_t circuit_id[] = { 0x68, 0x6f, 0x77, 0x64, 0x79 };
     OptionPtr circuit_id_opt(new Option(Option::V4, RAI_OPTION_AGENT_CIRCUIT_ID,

diff --git a/src/lib/dhcp/libdhcp++.cc b/src/lib/dhcp/libdhcp++.cc
index a98bea92b77898f252fc66c9de18f7783dfceab8..fd790a6ebf8a6d2f57ad32626a95c3780650ca4f 100644 (file)
--- a/src/lib/dhcp/libdhcp++.cc
+++ b/src/lib/dhcp/libdhcp++.cc
@@ -1291,6 +1291,19 @@ LibDHCP::initOptionDefs() {
                         OPTION_DEF_PARAMS[i].size);
     }
 
+    static_cast<void>(LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF());
+    static_cast<void>(LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF());
+    static_cast<void>(LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF());
+    static_cast<void>(LibDHCP::DHO_SUBNET_SELECTION_DEF());
+    static_cast<void>(LibDHCP::DHO_DOMAIN_SEARCH_DEF());
+    static_cast<void>(LibDHCP::DHO_STATUS_CODE_DEF());
+    static_cast<void>(LibDHCP::D6O_CLIENT_FQDN_DEF());
+    static_cast<void>(LibDHCP::D6O_LQ_QUERY_DEF());
+    static_cast<void>(LibDHCP::D6O_CLIENT_DATA_DEF());
+    static_cast<void>(LibDHCP::D6O_LQ_RELAY_DATA_DEF());
+    static_cast<void>(LibDHCP::D6O_BOOTFILE_URL_DEF());
+    static_cast<void>(LibDHCP::D6O_RSOO_DEF());
+
     return (true);
 }
 
@@ -1383,3 +1396,219 @@ initOptionSpace(OptionDefContainerPtr& defs, const OptionDefParams* params,
         static_cast<void>(defs->push_back(definition));
     }
 }
+
+const OptionDefinition&
+LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_REQUESTED_ADDRESS);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "dhcp-requested-address");
+        isc_throw_assert(def->getCode() == DHO_DHCP_REQUESTED_ADDRESS);
+        isc_throw_assert(def->getType() == OPT_IPV4_ADDRESS_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_SERVER_IDENTIFIER);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "dhcp-server-identifier");
+        isc_throw_assert(def->getCode() == DHO_DHCP_SERVER_IDENTIFIER);
+        isc_throw_assert(def->getType() == OPT_IPV4_ADDRESS_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DHCP_AGENT_OPTIONS);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "dhcp-agent-options");
+        isc_throw_assert(def->getCode() == DHO_DHCP_AGENT_OPTIONS);
+        isc_throw_assert(def->getType() == OPT_EMPTY_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace() == DHCP_AGENT_OPTION_SPACE);
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::DHO_SUBNET_SELECTION_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_SUBNET_SELECTION);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "subnet-selection");
+        isc_throw_assert(def->getCode() == DHO_SUBNET_SELECTION);
+        isc_throw_assert(def->getType() == OPT_IPV4_ADDRESS_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::DHO_DOMAIN_SEARCH_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_DOMAIN_SEARCH);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "domain-search");
+        isc_throw_assert(def->getCode() == DHO_DOMAIN_SEARCH);
+        isc_throw_assert(def->getType() == OPT_FQDN_TYPE);
+        isc_throw_assert(def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::DHO_STATUS_CODE_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP4_OPTION_SPACE, DHO_STATUS_CODE);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "status-code");
+        isc_throw_assert(def->getCode() == DHO_STATUS_CODE);
+        isc_throw_assert(def->getType() == OPT_RECORD_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP4_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_CLIENT_FQDN_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_FQDN);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "client-fqdn");
+        isc_throw_assert(def->getCode() == D6O_CLIENT_FQDN);
+        isc_throw_assert(def->getType() == OPT_RECORD_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_LQ_QUERY_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_LQ_QUERY);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "lq-query");
+        isc_throw_assert(def->getCode() == D6O_LQ_QUERY);
+        isc_throw_assert(def->getType() == OPT_RECORD_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace() == DHCP6_OPTION_SPACE);
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_CLIENT_DATA_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_DATA);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "client-data");
+        isc_throw_assert(def->getCode() == D6O_CLIENT_DATA);
+        isc_throw_assert(def->getType() == OPT_EMPTY_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace() == DHCP6_OPTION_SPACE);
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_LQ_RELAY_DATA_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_LQ_RELAY_DATA);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "lq-relay-data");
+        isc_throw_assert(def->getCode() == D6O_LQ_RELAY_DATA);
+        isc_throw_assert(def->getType() == OPT_RECORD_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_BOOTFILE_URL_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_BOOTFILE_URL);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "bootfile-url");
+        isc_throw_assert(def->getCode() == D6O_BOOTFILE_URL);
+        isc_throw_assert(def->getType() == OPT_STRING_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace().empty());
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}
+
+const OptionDefinition&
+LibDHCP::D6O_RSOO_DEF() {
+    static OptionDefinitionPtr def =
+        LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_RSOO);
+    static bool check_once(true);
+    if (check_once) {
+        isc_throw_assert(def);
+        isc_throw_assert(def->getName() == "rsoo");
+        isc_throw_assert(def->getCode() == D6O_RSOO);
+        isc_throw_assert(def->getType() == OPT_EMPTY_TYPE);
+        isc_throw_assert(!def->getArrayType());
+        isc_throw_assert(def->getEncapsulatedSpace() == "rsoo-opts");
+        isc_throw_assert(def->getOptionSpaceName() == DHCP6_OPTION_SPACE);
+        check_once = false;
+    }
+    return (*def);
+}

diff --git a/src/lib/dhcp/libdhcp++.h b/src/lib/dhcp/libdhcp++.h
index 452b2b9830ec9ec3adf0cd0d217979f69df47ecd..3de55167ceac00e33bd3cca09ad9978f25be8bd2 100644 (file)
--- a/src/lib/dhcp/libdhcp++.h
+++ b/src/lib/dhcp/libdhcp++.h
@@ -1,4 +1,4 @@
-// Copyright (C) 2011-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 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
@@ -426,6 +426,42 @@ public:
     /// @return vendor id.
     static uint32_t optionSpaceToVendorId(const std::string& option_space);
 
+    /// @brief Get definition of DHO_DHCP_REQUESTED_ADDRESS option.
+    static const OptionDefinition& DHO_DHCP_REQUESTED_ADDRESS_DEF();
+
+    /// @brief Get definition of DHO_DHCP_SERVER_IDENTIFIER option.
+    static const OptionDefinition& DHO_DHCP_SERVER_IDENTIFIER_DEF();
+
+    /// @brief Get definition of DHO_DHCP_AGENT_OPTIONS option.
+    static const OptionDefinition& DHO_DHCP_AGENT_OPTIONS_DEF();
+
+    /// @brief Get definition of DHO_SUBNET_SELECTION option.
+    static const OptionDefinition& DHO_SUBNET_SELECTION_DEF();
+
+    /// @brief Get definition of DHO_DOMAIN_SEARCH option.
+    static const OptionDefinition& DHO_DOMAIN_SEARCH_DEF();
+
+    /// @brief Get definition of DHO_STATUS_CODE option.
+    static const OptionDefinition& DHO_STATUS_CODE_DEF();
+
+    /// @brief Get definition of D6O_CLIENT_FQDN option.
+    static const OptionDefinition& D6O_CLIENT_FQDN_DEF();
+
+    /// @brief Get definition of D6O_LQ_QUERY option.
+    static const OptionDefinition& D6O_LQ_QUERY_DEF();
+
+    /// @brief Get definition of D6O_CLIENT_DATA option.
+    static const OptionDefinition& D6O_CLIENT_DATA_DEF();
+
+    /// @brief Get definition of D6O_LQ_RELAY_DATA option.
+    static const OptionDefinition& D6O_LQ_RELAY_DATA_DEF();
+
+    /// @brief Get definition of D6O_BOOTFILE_URL option.
+    static const OptionDefinition& D6O_BOOTFILE_URL_DEF();
+
+    /// @brief Get definition of D6O_RSOO option.
+    static const OptionDefinition& D6O_RSOO_DEF();
+
 private:
 
     /// Initialize DHCP option definitions.

diff --git a/src/lib/dhcp/tests/libdhcp++_unittest.cc b/src/lib/dhcp/tests/libdhcp++_unittest.cc
index 086de7400581a778f46692d0c5db216435ad9796..948a12963de849929a2095d02c22274fa4452e3d 100644 (file)
--- a/src/lib/dhcp/tests/libdhcp++_unittest.cc
+++ b/src/lib/dhcp/tests/libdhcp++_unittest.cc
@@ -1354,11 +1354,9 @@ TEST_F(LibDhcpTest, splitLongOptionMultiThreading) {
 // every suboption is smaller than 255 bytes, but the parent option still
 // overflows.
 TEST_F(LibDhcpTest, splitOptionWithSuboptionWhichOverflow) {
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     // Create a buffer holding some binary data. This data will be
     // used as reference when we read back the data from a created
@@ -1390,11 +1388,9 @@ TEST_F(LibDhcpTest, splitOptionWithSuboptionWhichOverflow) {
 // every suboption is smaller than 255 bytes, but the parent option still
 // overflows.
 TEST_F(LibDhcpTest, splitOptionWithSuboptionWhichOverflowMultiThreading) {
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     // Create a buffer holding some binary data. This data will be
     // used as reference when we read back the data from a created
@@ -1438,11 +1434,9 @@ TEST_F(LibDhcpTest, splitOptionWithSuboptionWhichOverflowMultiThreading) {
 
 // This test verifies that split options for v4 is working correctly.
 TEST_F(LibDhcpTest, splitLongOptionWithLongSuboption) {
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     // Create a buffer holding some binary data. This data will be
     // used as reference when we read back the data from a created
@@ -1480,11 +1474,9 @@ TEST_F(LibDhcpTest, splitLongOptionWithLongSuboption) {
 
 // This test verifies that split options for v4 is working correctly.
 TEST_F(LibDhcpTest, splitLongOptionWithLongSuboptionMultiThreading) {
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     // Create a buffer holding some binary data. This data will be
     // used as reference when we read back the data from a created
@@ -1575,11 +1567,9 @@ TEST_F(LibDhcpTest, fuseLongOption) {
 TEST_F(LibDhcpTest, fuseLongOptionWithLongSuboption) {
     OptionCollection col;
 
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                         DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI options which should be fused by the server.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     for (uint32_t i = 0; i < 256; ++i) {
         // Create a buffer holding some binary data. This data will be
@@ -1797,11 +1787,9 @@ TEST_F(LibDhcpTest, packOptions4) {
     // Get the option definition for RAI option. This option is represented
     // by OptionCustom which requires a definition to be passed to
     // the constructor.
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     // Create RAI option.
-    OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4));
+    OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4));
 
     // The sub-options are created using the bits of v4_opts buffer because
     // we want to use this buffer as a reference to verify that produced
@@ -3272,10 +3260,7 @@ TEST_F(LibDhcpTest, getVendorOptionDefByName4) {
 
 // This test checks handling of uncompressed FQDN list.
 TEST_F(LibDhcpTest, fqdnList) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DOMAIN_SEARCH);
-    ASSERT_TRUE(def);
-
+    const OptionDefinition& def = LibDHCP::DHO_DOMAIN_SEARCH_DEF();
     // Prepare buffer holding an array of FQDNs.
     const uint8_t fqdn[] = {
         8, 109, 121, 100, 111, 109, 97, 105, 110, // "mydomain"
@@ -3295,10 +3280,10 @@ TEST_F(LibDhcpTest, fqdnList) {
     std::vector<uint8_t> fqdn_buf(fqdn, fqdn + sizeof(fqdn));
 
     OptionPtr option;
-    ASSERT_NO_THROW(option = def->optionFactory(Option::V4,
-                                                DHO_DOMAIN_SEARCH,
-                                                fqdn_buf.begin(),
-                                                fqdn_buf.end()));
+    ASSERT_NO_THROW(option = def.optionFactory(Option::V4,
+                                               DHO_DOMAIN_SEARCH,
+                                               fqdn_buf.begin(),
+                                               fqdn_buf.end()));
     ASSERT_TRUE(option);
     OptionCustomPtr names = boost::dynamic_pointer_cast<OptionCustom>(option);
     ASSERT_TRUE(names);
@@ -3316,10 +3301,7 @@ TEST_F(LibDhcpTest, fqdnList) {
 // See RFC3397, section 2 (and 4.1.4 of RFC1035 for the actual
 // compression algorithm).
 TEST_F(LibDhcpTest, fqdnListCompressed) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DOMAIN_SEARCH);
-    ASSERT_TRUE(def);
-
+    const OptionDefinition& def = LibDHCP::DHO_DOMAIN_SEARCH_DEF();
     const uint8_t compressed[] = {
         8, 109, 121, 100, 111, 109, 97, 105, 110, // "mydomain"
         7, 101, 120, 97, 109, 112, 108, 101,      // "example"
@@ -3331,10 +3313,10 @@ TEST_F(LibDhcpTest, fqdnListCompressed) {
     std::vector<uint8_t> compressed_buf(compressed,
                                         compressed + sizeof(compressed));
     OptionPtr option;
-    ASSERT_NO_THROW(option = def->optionFactory(Option::V4,
-                                                DHO_DOMAIN_SEARCH,
-                                                compressed_buf.begin(),
-                                                compressed_buf.end()));
+    ASSERT_NO_THROW(option = def.optionFactory(Option::V4,
+                                               DHO_DOMAIN_SEARCH,
+                                               compressed_buf.begin(),
+                                               compressed_buf.end()));
     ASSERT_TRUE(option);
     OptionCustomPtr names = boost::dynamic_pointer_cast<OptionCustom>(option);
     ASSERT_TRUE(names);
@@ -3350,10 +3332,7 @@ TEST_F(LibDhcpTest, fqdnListCompressed) {
 // See RFC3397, section 2 (and 4.1.4 of RFC1035 for the actual
 // compression algorithm).
 TEST_F(LibDhcpTest, fqdnListBad) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DOMAIN_SEARCH);
-    ASSERT_TRUE(def);
-
+    const OptionDefinition& def = LibDHCP::DHO_DOMAIN_SEARCH_DEF();
     const uint8_t bad[] = {
         8, 109, 121, 100, 111, 109, 97, 105, 110, // "mydomain"
         7, 101, 120, 97, 109, 112, 108, 101,      // "example"
@@ -3365,26 +3344,24 @@ TEST_F(LibDhcpTest, fqdnListBad) {
     std::vector<uint8_t> bad_buf(bad, bad + sizeof(bad));
 
     OptionPtr option;
-    EXPECT_THROW(option = def->optionFactory(Option::V4,
-                                             DHO_DOMAIN_SEARCH,
-                                             bad_buf.begin(),
-                                             bad_buf.end()),
+    EXPECT_THROW(option = def.optionFactory(Option::V4,
+                                            DHO_DOMAIN_SEARCH,
+                                            bad_buf.begin(),
+                                            bad_buf.end()),
                  InvalidOptionValue);
 }
 
 // Check that empty (truncated) option is rejected.
 TEST_F(LibDhcpTest, fqdnListTrunc) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DOMAIN_SEARCH);
-    ASSERT_TRUE(def);
+    const OptionDefinition& def = LibDHCP::DHO_DOMAIN_SEARCH_DEF();
 
     std::vector<uint8_t> empty;
 
     OptionPtr option;
-    EXPECT_THROW(option = def->optionFactory(Option::V4,
-                                             DHO_DOMAIN_SEARCH,
-                                             empty.begin(),
-                                             empty.end()),
+    EXPECT_THROW(option = def.optionFactory(Option::V4,
+                                            DHO_DOMAIN_SEARCH,
+                                            empty.begin(),
+                                            empty.end()),
                  InvalidOptionValue);
 }
 

diff --git a/src/lib/dhcp/tests/pkt6_unittest.cc b/src/lib/dhcp/tests/pkt6_unittest.cc
index 5bf739872e8a71ff4aeccf729561104b7d2b81da..adb7c5f9661a0caaf1e5cae3e3ac28667cc6552f 100644 (file)
--- a/src/lib/dhcp/tests/pkt6_unittest.cc
+++ b/src/lib/dhcp/tests/pkt6_unittest.cc
@@ -2131,10 +2131,8 @@ TEST_F(Pkt6Test, testSkipThisOptionError) {
 // and unpacked correctly.
 TEST_F(Pkt6Test, lqQueryOption) {
 
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_LQ_QUERY);
-    ASSERT_TRUE(def) << "D6O_LQ_QUERY is not undefined";
-
-    OptionCustomPtr lq_option(new OptionCustom(*def, Option::V6));
+    const OptionDefinition& def = LibDHCP::D6O_LQ_QUERY_DEF();
+    OptionCustomPtr lq_option(new OptionCustom(def, Option::V6));
     ASSERT_TRUE(lq_option);
 
     // Add query type (77 is technically not valid but better visually).
@@ -2223,10 +2221,9 @@ TEST_F(Pkt6Test, lqQueryOption) {
 // and unpacked correctly.
 TEST_F(Pkt6Test, clientDataOption) {
 
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_DATA);
-    ASSERT_TRUE(def) << "D6O_CLIENT_DATA is not undefined";
+    const OptionDefinition& def = LibDHCP::D6O_CLIENT_DATA_DEF();
 
-    OptionCustomPtr cd_option(new OptionCustom(*def, Option::V6));
+    OptionCustomPtr cd_option(new OptionCustom(def, Option::V6));
     ASSERT_TRUE(cd_option);
 
     // Now add supported sub-options: D6O_CLIENTID, D6O_IAADR, D6O_IAAPREFIX,
@@ -2327,10 +2324,9 @@ TEST_F(Pkt6Test, clientDataOption) {
 // This test verifies that D6O_LQ_RELAY_DATA options can be created, packed,
 // and unpacked correctly.
 TEST_F(Pkt6Test, relayDataOption) {
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_LQ_RELAY_DATA);
-    ASSERT_TRUE(def) << "D6O_LQ_RELAY_DATA is not undefined";
+    const OptionDefinition& def = LibDHCP::D6O_LQ_RELAY_DATA_DEF();
 
-    OptionCustomPtr rd_option(new OptionCustom(*def, Option::V6));
+    OptionCustomPtr rd_option(new OptionCustom(def, Option::V6));
     ASSERT_TRUE(rd_option);
 
     // Write out the peer address.

diff --git a/src/lib/dhcpsrv/lease_mgr.cc b/src/lib/dhcpsrv/lease_mgr.cc
index ec46fe2f972bebf14d11e62ae948da5491355f27..bb34c1dd63b09a4f463cc8f7ca12e3deed90b6c4 100644 (file)
--- a/src/lib/dhcpsrv/lease_mgr.cc
+++ b/src/lib/dhcpsrv/lease_mgr.cc
@@ -534,7 +534,7 @@ LeaseMgr::setExtendedInfoTablesEnabled(const DatabaseConnection::ParameterMap& p
 bool
 LeaseMgr::upgradeLease4ExtendedInfo(const Lease4Ptr& lease,
                                     CfgConsistency::ExtendedInfoSanity check) {
-    static OptionDefinitionPtr rai_def;
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
 
     bool changed = false;
     if (!lease) {
@@ -550,17 +550,6 @@ LeaseMgr::upgradeLease4ExtendedInfo(const Lease4Ptr& lease,
         return (changed);
     }
 
-    if (!rai_def) {
-        rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                        DHO_DHCP_AGENT_OPTIONS);
-    }
-
-    if (!rai_def) {
-        // The definition is set when libdhcp++ is loaded so it is impossible
-        // to not be able to get it... so should not happen!
-        isc_throw(Unexpected, "can't find RAI option definition?!");
-    }
-
     ConstElementPtr isc;
     ConstElementPtr extended_info;
     ElementPtr mutable_user_context;
@@ -628,7 +617,7 @@ LeaseMgr::upgradeLease4ExtendedInfo(const Lease4Ptr& lease,
             string rai_hex = extended_info->stringValue();
             vector<uint8_t> rai_data;
             str::decodeFormattedHexString(rai_hex, rai_data);
-            OptionCustomPtr rai(new OptionCustom(*rai_def, Option::V4, rai_data));
+            OptionCustomPtr rai(new OptionCustom(rai_def, Option::V4, rai_data));
             if (!rai) {
                 isc_throw(BadValue, "can't create RAI option");
             }

diff --git a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
index 73939315b2db534e0380bc5dd59b375b03f71d54..8a4286ad590816598bc87d1d1e5e518f7c99dad8 100644 (file)
--- a/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
+++ b/src/lib/dhcpsrv/tests/alloc_engine4_unittest.cc
@@ -3879,17 +3879,14 @@ TEST_F(AllocEngine4Test, updateExtendedInfo4) {
             std::vector<uint8_t> opt_data;
             ASSERT_NO_THROW(util::str::decodeFormattedHexString(scenario.rai_data_, opt_data))
                             << "scenario.rai_data_ is invalid, test is broken";
-            OptionDefinitionPtr rai_def =
-                LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                      DHO_DHCP_AGENT_OPTIONS);
-            ASSERT_TRUE(rai_def) <<  "could not get RAI definition, test is broken";
+            const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
             ASSERT_GT(opt_data.size(), 2);
             ASSERT_EQ(DHO_DHCP_AGENT_OPTIONS, opt_data[0]);
             ASSERT_EQ(opt_data[1] + 2, opt_data.size());
             std::vector<uint8_t> rai_data(opt_data.cbegin() + 2,
                                           opt_data.cend());
             OptionCustomPtr rai;
-            ASSERT_NO_THROW(rai.reset(new OptionCustom(*rai_def, Option::V4,
+            ASSERT_NO_THROW(rai.reset(new OptionCustom(rai_def, Option::V4,
                                                        rai_data)))
                 << "could not create rai option, test is broken";
             ctx.query_->addOption(rai);
@@ -3934,11 +3931,9 @@ TEST_F(AllocEngine4Test, stashAgentOptions) {
     std::string rai_str = "0104aabbccdd";
     std::vector<uint8_t> rai_data;
     ASSERT_NO_THROW(util::str::decodeFormattedHexString(rai_str, rai_data));
-    OptionDefinitionPtr rai_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                        DHO_DHCP_AGENT_OPTIONS);
-    ASSERT_TRUE(rai_def);
+    const OptionDefinition& rai_def = LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF();
     OptionCustomPtr rai;
-    ASSERT_NO_THROW(rai.reset(new OptionCustom(*rai_def, Option::V4, rai_data)));
+    ASSERT_NO_THROW(rai.reset(new OptionCustom(rai_def, Option::V4, rai_data)));
     ctx.query_->addOption(rai);
 
     // Verifies that the RAI is saved into lease extended info.

diff --git a/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc b/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
index 2e1540715921d0172d8d99d6c32f951e76f7b4b3..4c0b688130c8691b55adb1084756fa69feaaad87 100644 (file)
--- a/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
+++ b/src/lib/dhcpsrv/tests/cfg_subnets4_unittest.cc
@@ -1285,9 +1285,8 @@ TEST(CfgSubnets4Test, hasSubnetWithServerId) {
     // Initially, there is no server identifier option present.
     EXPECT_FALSE(cfg.hasSubnetWithServerId(IOAddress("1.2.3.4")));
 
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                    DHO_DHCP_SERVER_IDENTIFIER);
-    OptionCustomPtr opt_server_id(new OptionCustom(*def, Option::V4));
+    const OptionDefinition& def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
+    OptionCustomPtr opt_server_id(new OptionCustom(def, Option::V4));
     opt_server_id->writeAddress(IOAddress("1.2.3.4"));
     Subnet4Ptr subnet(new Subnet4(IOAddress("192.0.2.0"), 26, 1, 2, 3, 100));
     subnet->getCfgOption()->add(opt_server_id, false, false,

diff --git a/src/lib/dhcpsrv/tests/dhcp_parsers_unittest.cc b/src/lib/dhcpsrv/tests/dhcp_parsers_unittest.cc
index c11891bb23bc5cbab53c37bead370340649d4068..a715ae93f5daf382302780a8258b712868da296f 100644 (file)
--- a/src/lib/dhcpsrv/tests/dhcp_parsers_unittest.cc
+++ b/src/lib/dhcpsrv/tests/dhcp_parsers_unittest.cc
@@ -3478,10 +3478,6 @@ TEST_F(ParseConfigTest, invalidSubnetPdAllocator6) {
 // Verifies that parsing an option which encapsulates its own option space
 // is detected.
 TEST_F(ParseConfigTest, selfEncapsulationTest) {
-    // Verify that the option definition can be retrieved.
-    OptionDefinitionPtr def = LibDHCP::getOptionDef(DHCP6_OPTION_SPACE, D6O_CLIENT_DATA);
-    ASSERT_TRUE(def);
-
     // Configuration string.
     std::string config =
         "{"

diff --git a/src/lib/dhcpsrv/tests/subnet_unittest.cc b/src/lib/dhcpsrv/tests/subnet_unittest.cc
index 8b7ecce3a9ac4aaaac817fd85dd844ddd52e317f..1badddbd12d7834c8b0d0e4ea639084214f81a1e 100644 (file)
--- a/src/lib/dhcpsrv/tests/subnet_unittest.cc
+++ b/src/lib/dhcpsrv/tests/subnet_unittest.cc
@@ -746,9 +746,8 @@ TEST(Subnet4Test, getServerId) {
     EXPECT_TRUE(subnet.getServerId().isV4Zero());
 
     // Add server identifier.
-    OptionDefinitionPtr option_def = LibDHCP::getOptionDef(DHCP4_OPTION_SPACE,
-                                                           DHO_DHCP_SERVER_IDENTIFIER);
-    OptionCustomPtr option_server_id(new OptionCustom(*option_def, Option::V4));
+    const OptionDefinition& option_def = LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF();
+    OptionCustomPtr option_server_id(new OptionCustom(option_def, Option::V4));
     option_server_id->writeAddress(IOAddress("1.2.3.4"));
 
     CfgOptionPtr cfg_option = subnet.getCfgOption();