From: Francis Dupont Date: Sun, 2 Jun 2024 15:00:55 +0000 (+0200) Subject: [#2755] Code done, doc to update X-Git-Tag: Kea-2.7.0~45 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=58cc9eb76c08598301610ff4c0340efa5b681601;p=thirdparty%2Fkea.git [#2755] Code done, doc to update --- diff --git a/src/bin/dhcp4/dhcp4_srv.cc b/src/bin/dhcp4/dhcp4_srv.cc index dbbc728327..664a0ecdbc 100644 --- a/src/bin/dhcp4/dhcp4_srv.cc +++ b/src/bin/dhcp4/dhcp4_srv.cc @@ -4392,16 +4392,8 @@ Dhcpv4Srv::recoverStashedAgentOption(const Pkt4Ptr& query) { } vector 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 b97776e72e..a044fadabb 100644 --- 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 94dfe6f48f..8f303b9d3d 100644 --- 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 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 a91e45d70c..88e80a33e1 100644 --- 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 1f790c4dea..ca73c0e4f0 100644 --- 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& 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 c5149ba527..169d8ba3ee 100644 --- 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 0b6d9203e2..1ada762b60 100644 --- 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 a98bea92b7..fd790a6ebf 100644 --- 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(LibDHCP::DHO_DHCP_REQUESTED_ADDRESS_DEF()); + static_cast(LibDHCP::DHO_DHCP_SERVER_IDENTIFIER_DEF()); + static_cast(LibDHCP::DHO_DHCP_AGENT_OPTIONS_DEF()); + static_cast(LibDHCP::DHO_SUBNET_SELECTION_DEF()); + static_cast(LibDHCP::DHO_DOMAIN_SEARCH_DEF()); + static_cast(LibDHCP::DHO_STATUS_CODE_DEF()); + static_cast(LibDHCP::D6O_CLIENT_FQDN_DEF()); + static_cast(LibDHCP::D6O_LQ_QUERY_DEF()); + static_cast(LibDHCP::D6O_CLIENT_DATA_DEF()); + static_cast(LibDHCP::D6O_LQ_RELAY_DATA_DEF()); + static_cast(LibDHCP::D6O_BOOTFILE_URL_DEF()); + static_cast(LibDHCP::D6O_RSOO_DEF()); + return (true); } @@ -1383,3 +1396,219 @@ initOptionSpace(OptionDefContainerPtr& defs, const OptionDefParams* params, static_cast(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 452b2b9830..3de55167ce 100644 --- 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 086de74005..948a12963d 100644 --- 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 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(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 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(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 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 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 5bf739872e..adb7c5f966 100644 --- 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 ec46fe2f97..bb34c1dd63 100644 --- 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 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 73939315b2..8a4286ad59 100644 --- 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 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 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 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 2e15407159..4c0b688130 100644 --- 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 c11891bb23..a715ae93f5 100644 --- 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 8b7ecce3a9..1badddbd12 100644 --- 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();