From: Marcin Siodelski Date: Thu, 19 May 2016 11:48:56 +0000 (+0200) Subject: [4498] Removed support for callback functions unpacking options. X-Git-Tag: fdxhook_base~5^2~2 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=24a243501da19965a437d83f398d5b3d3e405b52;p=thirdparty%2Fkea.git [4498] Removed support for callback functions unpacking options. Previously we used callback functions to pass a pointer to the server-side function unpacking options. Currently we register runtime option definitions in libdhcp++, so the callback functions are not necessary anymore. --- diff --git a/src/lib/dhcp/option.cc b/src/lib/dhcp/option.cc index 9b4246eeed..b3f8786980 100644 --- a/src/lib/dhcp/option.cc +++ b/src/lib/dhcp/option.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2011-2016 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 @@ -129,13 +129,6 @@ void Option::unpack(OptionBufferConstIter begin, void Option::unpackOptions(const OptionBuffer& buf) { - // If custom option parsing function has been set, use this function - // to parse options. Otherwise, use standard function from libdhcp++. - if (!callback_.empty()) { - callback_(buf, getEncapsulatedSpace(), options_, 0, 0); - return; - } - switch (universe_) { case V4: LibDHCP::unpackOptions4(buf, getEncapsulatedSpace(), options_); diff --git a/src/lib/dhcp/option.h b/src/lib/dhcp/option.h index 78e768686d..61eade0d64 100644 --- a/src/lib/dhcp/option.h +++ b/src/lib/dhcp/option.h @@ -1,4 +1,4 @@ -// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2011-2016 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 @@ -42,32 +42,6 @@ typedef std::multimap OptionCollection; /// A pointer to an OptionCollection typedef boost::shared_ptr OptionCollectionPtr; -/// @brief This type describes a callback function to parse options from buffer. -/// -/// @note The last two parameters should be specified in the callback function -/// parameters list only if DHCPv6 options are parsed. Exclude these parameters -/// from the callback function defined to parse DHCPv4 options. -/// -/// @param buffer A buffer holding options to be parsed. -/// @param encapsulated_space A name of the option space to which options being -/// parsed belong. -/// @param [out] options A container to which parsed options should be appended. -/// @param relay_msg_offset A pointer to a size_t value. It indicates the -/// offset to beginning of relay_msg option. This parameter should be specified -/// for DHCPv6 options only. -/// @param relay_msg_len A pointer to a size_t value. It holds the length of -/// of the relay_msg option. This parameter should be specified for DHCPv6 -/// options only. -/// -/// @return An offset to the first byte after last parsed option. -typedef boost::function< size_t(const OptionBuffer& buffer, - const std::string encapsulated_space, - OptionCollection& options, - size_t* relay_msg_offset, - size_t* relay_msg_len) - > UnpackOptionsCallback; - - class Option { public: /// length of the usual DHCPv4 option header (there are exceptions) @@ -361,14 +335,6 @@ public: return (encapsulated_space_); } - /// @brief Set callback function to be used to parse options. - /// - /// @param callback An instance of the callback function or NULL to - /// uninstall callback. - void setCallback(UnpackOptionsCallback callback) { - callback_ = callback; - } - /// just to force that every option has virtual dtor virtual ~Option(); @@ -492,9 +458,6 @@ protected: /// Name of the option space being encapsulated by this option. std::string encapsulated_space_; - /// A callback to be called to unpack options from the packet. - UnpackOptionsCallback callback_; - /// @todo probably 2 different containers have to be used for v4 (unique /// options) and v6 (options with the same type can repeat) }; diff --git a/src/lib/dhcp/option_definition.cc b/src/lib/dhcp/option_definition.cc index 9fb2d56ab3..22744b5f28 100644 --- a/src/lib/dhcp/option_definition.cc +++ b/src/lib/dhcp/option_definition.cc @@ -121,8 +121,7 @@ OptionDefinition::addRecordField(const OptionDataType data_type) { OptionPtr OptionDefinition::optionFactory(Option::Universe u, uint16_t type, OptionBufferConstIter begin, - OptionBufferConstIter end, - UnpackOptionsCallback callback) const { + OptionBufferConstIter end) const { try { // Some of the options are represented by the specialized classes derived @@ -131,7 +130,7 @@ OptionDefinition::optionFactory(Option::Universe u, uint16_t type, // type to be returned. Therefore, we first check that if we are dealing // with such an option. If the instance is returned we just exit at this // point. If not, we will search for a generic option type to return. - OptionPtr option = factorySpecialFormatOption(u, begin, end, callback); + OptionPtr option = factorySpecialFormatOption(u, begin, end); if (option) { return (option); } @@ -151,37 +150,37 @@ OptionDefinition::optionFactory(Option::Universe u, uint16_t type, return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_INT8_TYPE: return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_UINT16_TYPE: return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_INT16_TYPE: return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_UINT32_TYPE: return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_INT32_TYPE: return (array_type_ ? factoryIntegerArray(u, type, begin, end) : factoryInteger(u, type, getEncapsulatedSpace(), - begin, end, callback)); + begin, end)); case OPT_IPV4_ADDRESS_TYPE: // If definition specifies that an option is an array @@ -217,9 +216,8 @@ OptionDefinition::optionFactory(Option::Universe u, uint16_t type, OptionPtr OptionDefinition::optionFactory(Option::Universe u, uint16_t type, - const OptionBuffer& buf, - UnpackOptionsCallback callback) const { - return (optionFactory(u, type, buf.begin(), buf.end(), callback)); + const OptionBuffer& buf) const { + return (optionFactory(u, type, buf.begin(), buf.end())); } OptionPtr @@ -662,8 +660,7 @@ OptionDefinition::factoryIAPrefix6(uint16_t type, OptionPtr OptionDefinition::factorySpecialFormatOption(Option::Universe u, OptionBufferConstIter begin, - OptionBufferConstIter end, - UnpackOptionsCallback) const { + OptionBufferConstIter end) const { if (u == Option::V6) { if ((getCode() == D6O_IA_NA || getCode() == D6O_IA_PD) && haveIA6Format()) { diff --git a/src/lib/dhcp/option_definition.h b/src/lib/dhcp/option_definition.h index 91fb9181e2..a3b94e8ba7 100644 --- a/src/lib/dhcp/option_definition.h +++ b/src/lib/dhcp/option_definition.h @@ -1,4 +1,4 @@ -// Copyright (C) 2012-2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2012-2016 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 @@ -382,17 +382,12 @@ public: /// @param type option type. /// @param begin beginning of the option buffer. /// @param end end of the option buffer. - /// @param callback An instance of the function which parses packet options. - /// If this is set to non NULL value this function will be used instead of - /// @c isc::dhcp::LibDHCP::unpackOptions6 and - /// isc::dhcp::LibDHCP::unpackOptions4. /// /// @return instance of the DHCP option. /// @throw InvalidOptionValue if data for the option is invalid. OptionPtr optionFactory(Option::Universe u, uint16_t type, OptionBufferConstIter begin, - OptionBufferConstIter end, - UnpackOptionsCallback callback = NULL) const; + OptionBufferConstIter end) const; /// @brief Option factory. /// @@ -407,16 +402,11 @@ public: /// @param u option universe (V4 or V6). /// @param type option type. /// @param buf option buffer. - /// @param callback An instance of the function which parses packet options. - /// If this is set to non NULL value this function will be used instead of - /// @c isc::dhcp::LibDHCP::unpackOptions6 and - /// isc::dhcp::LibDHCP::unpackOptions4. /// /// @return instance of the DHCP option. /// @throw InvalidOptionValue if data for the option is invalid. OptionPtr optionFactory(Option::Universe u, uint16_t type, - const OptionBuffer& buf = OptionBuffer(), - UnpackOptionsCallback callback = NULL) const; + const OptionBuffer& buf = OptionBuffer()) const; /// @brief Option factory. /// @@ -534,10 +524,6 @@ public: /// encapsulated option space are sub options of this option. /// @param begin iterator pointing to the beginning of the buffer. /// @param end iterator pointing to the end of the buffer. - /// @param callback An instance of the function which parses packet options. - /// If this is set to non NULL value this function will be used instead of - /// @c isc::dhcp::LibDHCP::unpackOptions6 and - /// isc::dhcp::LibDHCP::unpackOptions4. /// @tparam T type of the data field (must be one of the uintX_t or intX_t). /// /// @throw isc::OutOfRange if provided option buffer length is invalid. @@ -545,11 +531,9 @@ public: static OptionPtr factoryInteger(Option::Universe u, uint16_t type, const std::string& encapsulated_space, OptionBufferConstIter begin, - OptionBufferConstIter end, - UnpackOptionsCallback callback) { + OptionBufferConstIter end) { OptionPtr option(new OptionInt(u, type, 0)); option->setEncapsulatedSpace(encapsulated_space); - option->setCallback(callback); option->unpack(begin, end); return (option); } @@ -586,18 +570,13 @@ private: /// @param u A universe (V4 or V6). /// @param begin beginning of the option buffer. /// @param end end of the option buffer. - /// @param callback An instance of the function which parses packet options. - /// If this is set to non NULL value this function will be used instead of - /// @c isc::dhcp::LibDHCP::unpackOptions6 and - /// isc::dhcp::LibDHCP::unpackOptions4. /// /// @return An instance of the option having special format or NULL if /// such an option can't be created because an option with the given /// option code hasn't got the special format. OptionPtr factorySpecialFormatOption(Option::Universe u, OptionBufferConstIter begin, - OptionBufferConstIter end, - UnpackOptionsCallback callback) const; + OptionBufferConstIter end) const; /// @brief Check if specified option format is a record with 3 fields /// where first one is custom, and two others are uint32. diff --git a/src/lib/dhcp/pkt.h b/src/lib/dhcp/pkt.h index abca52e5f6..75f70f978c 100644 --- a/src/lib/dhcp/pkt.h +++ b/src/lib/dhcp/pkt.h @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2014-2016 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 @@ -284,14 +284,6 @@ public: /// that we just received, a copy between those two buffers is necessary. void repack(); - /// @brief Set callback function to be used to parse options. - /// - /// @param callback An instance of the callback function or NULL to - /// uninstall callback. - void setCallback(UnpackOptionsCallback callback) { - callback_ = callback; - } - /// @brief Sets remote IP address. /// /// @param remote specifies remote address @@ -629,9 +621,6 @@ protected: // remote HW address (src if receiving packet, dst if sending packet) HWAddrPtr remote_hwaddr_; - /// A callback to be called to unpack options from the packet. - UnpackOptionsCallback callback_; - private: /// @brief Generic method that validates and sets HW address. diff --git a/src/lib/dhcp/pkt4.cc b/src/lib/dhcp/pkt4.cc index 3c980b5205..0e146a85a0 100644 --- a/src/lib/dhcp/pkt4.cc +++ b/src/lib/dhcp/pkt4.cc @@ -201,17 +201,9 @@ Pkt4::unpack() { // Use readVector because a function which parses option requires // a vector as an input. - size_t offset; buffer_in.readVector(opts_buffer, opts_len); - if (callback_.empty()) { - offset = LibDHCP::unpackOptions4(opts_buffer, "dhcp4", options_); - } else { - // The last two arguments are set to NULL because they are - // specific to DHCPv6 options parsing. They are unused for - // DHCPv4 case. In DHCPv6 case they hold are the relay message - // offset and length. - offset = callback_(opts_buffer, "dhcp4", options_, NULL, NULL); - } + + size_t offset = LibDHCP::unpackOptions4(opts_buffer, "dhcp4", options_); // If offset is not equal to the size and there is no DHO_END, // then something is wrong here. We either parsed past input diff --git a/src/lib/dhcp/pkt6.cc b/src/lib/dhcp/pkt6.cc index ac774c53a3..393cece498 100644 --- a/src/lib/dhcp/pkt6.cc +++ b/src/lib/dhcp/pkt6.cc @@ -336,15 +336,7 @@ Pkt6::unpackMsg(OptionBuffer::const_iterator begin, // If custom option parsing function has been set, use this function // to parse options. Otherwise, use standard function from libdhcp. - size_t offset; - if (callback_.empty()) { - offset = LibDHCP::unpackOptions6(opt_buffer, "dhcp6", options_); - } else { - // The last two arguments hold the DHCPv6 Relay message offset and - // length. Setting them to NULL because we are dealing with the - // not-relayed message. - offset = callback_(opt_buffer, "dhcp6", options_, NULL, NULL); - } + size_t offset = LibDHCP::unpackOptions6(opt_buffer, "dhcp6", options_); // If offset is not equal to the size, then something is wrong here. We // either parsed past input buffer (bug in our code) or we haven't parsed @@ -394,13 +386,8 @@ Pkt6::unpackRelayMsg() { // If custom option parsing function has been set, use this function // to parse options. Otherwise, use standard function from libdhcp. - if (callback_.empty()) { - LibDHCP::unpackOptions6(opt_buffer, "dhcp6", relay.options_, - &relay_msg_offset, &relay_msg_len); - } else { - callback_(opt_buffer, "dhcp6", relay.options_, - &relay_msg_offset, &relay_msg_len); - } + LibDHCP::unpackOptions6(opt_buffer, "dhcp6", relay.options_, + &relay_msg_offset, &relay_msg_len); /// @todo: check that each option appears at most once //relay.interface_id_ = options->getOption(D6O_INTERFACE_ID); diff --git a/src/lib/dhcp/tests/option_definition_unittest.cc b/src/lib/dhcp/tests/option_definition_unittest.cc index ccf658b0d3..00f4452bfb 100644 --- a/src/lib/dhcp/tests/option_definition_unittest.cc +++ b/src/lib/dhcp/tests/option_definition_unittest.cc @@ -1242,7 +1242,7 @@ TEST_F(OptionDefinitionTest, integerInvalidType) { OptionBuffer buf(1); EXPECT_THROW( OptionDefinition::factoryInteger(Option::V6, D6O_PREFERENCE, "dhcp6", - buf.begin(), buf.end(), NULL), + buf.begin(), buf.end()), isc::dhcp::InvalidDataType ); } diff --git a/src/lib/dhcp/tests/option_unittest.cc b/src/lib/dhcp/tests/option_unittest.cc index 2f8adda8b7..3d8289d47f 100644 --- a/src/lib/dhcp/tests/option_unittest.cc +++ b/src/lib/dhcp/tests/option_unittest.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2011-2015 Internet Systems Consortium, Inc. ("ISC") +// Copyright (C) 2011-2016 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 @@ -30,55 +30,6 @@ using boost::scoped_ptr; namespace { -/// @brief A class which contains a custom callback function to unpack options. -/// -/// This is a class used by the tests which verify that the custom callback -/// functions can be installed to unpack options from a message. When the -/// callback function is called, the executed_ member is set to true to allow -/// verification that the callback was really called. Internally, this class -/// uses libdhcp++ to unpack options so the options parsing algorithm remains -/// unchanged after installation of the callback. -class CustomUnpackCallback { -public: - - /// @brief Constructor - /// - /// Marks that callback hasn't been called. - CustomUnpackCallback() - : executed_(false) { - } - - /// @brief A callback - /// - /// Contains custom implementation of the callback. - /// - /// @param buf a A buffer holding options in on-wire format. - /// @param option_space A name of the option space being encapsulated by - /// the option being parsed. - /// @param [out] options A reference to the collection where parsed options - /// will be stored. - /// @param relay_msg_offset Reference to a size_t structure. If specified, - /// offset to beginning of relay_msg option will be stored in it. - /// @param relay_msg_len reference to a size_t structure. If specified, - /// length of the relay_msg option will be stored in it. - /// @return An offset to the first byte after last parsed option. - size_t execute(const OptionBuffer& buf, - const std::string& option_space, - isc::dhcp::OptionCollection& options, - size_t* relay_msg_offset, - size_t* relay_msg_len) { - // Set the executed_ member to true to allow verification that the - // callback has been actually called. - executed_ = true; - // Use default implementation of the unpack algorithm to parse options. - return (LibDHCP::unpackOptions6(buf, option_space, options, relay_msg_offset, - relay_msg_len)); - } - - /// A flag which indicates if callback function has been called. - bool executed_; -}; - /// @brief A class which derives from option and exposes protected members. class NakedOption : public Option { public: @@ -651,55 +602,4 @@ TEST_F(OptionTest, setEncapsulatedSpace) { } -// This test verifies that it is possible to specify custom implementation of -// the option parsing algorithm by installing a callback function. -TEST_F(OptionTest, unpackCallback) { - // Create a buffer which holds two sub options. - const char opt_data[] = { - 0x00, 0x01, // sub option code = 1 - 0x00, 0x02, // sub option length = 2 - 0x00, 0x01, // sub option data (2 bytes) - 0x00, 0x02, // sub option code = 2 - 0x00, 0x02, // sub option length = 2 - 0x01, 0x01 // sub option data (2 bytes) - }; - OptionBuffer opt_buf(opt_data, opt_data + sizeof(opt_data)); - - // Make sure that the flag which indicates if the callback function has - // been called is not set. Otherwise, our test doesn't make sense. - CustomUnpackCallback cb; - ASSERT_FALSE(cb.executed_); - // Create an option and install a callback. - NakedOption option; - // Parameters from _1 to _5 are placeholders for the actual values - // to be passed to the callback function. See: boost::bind documentation - // at http://www.boost.org/doc/libs/1_54_0/libs/bind/bind.html. - // Also, see UnpackOptionsCallback in option.h for description of the - // parameter values. - option.setCallback(boost::bind(&CustomUnpackCallback::execute, &cb, - _1, _2, _3, _4, _5)); - // Parse options. It should result in a call to our callback function. - // This function uses LibDHCP to parse options so they should be parsed - // correctly. - ASSERT_NO_THROW(option.unpackOptions(opt_buf)); - EXPECT_TRUE(option.getOption(1)); - EXPECT_TRUE(option.getOption(2)); - EXPECT_FALSE(option.getOption(3)); - // The callback should have been registered. - EXPECT_TRUE(cb.executed_); - // Reset the flag because now we are going to uninstall the callback and - // verify that it was NOT called. - cb.executed_ = false; - // Uninstall the callback. - option.setCallback(NULL); - ASSERT_NO_THROW(option.unpackOptions(opt_buf)); - // Options should still get unpacked... - EXPECT_TRUE(option.getOption(1)); - EXPECT_TRUE(option.getOption(2)); - EXPECT_FALSE(option.getOption(3)); - // ... but not via callback. - EXPECT_FALSE(cb.executed_); -} - - } diff --git a/src/lib/dhcp/tests/pkt4_unittest.cc b/src/lib/dhcp/tests/pkt4_unittest.cc index 1db3e61940..4fab1a8b55 100644 --- a/src/lib/dhcp/tests/pkt4_unittest.cc +++ b/src/lib/dhcp/tests/pkt4_unittest.cc @@ -39,48 +39,6 @@ using boost::scoped_ptr; namespace { -/// @brief A class which contains a custom callback function to unpack options. -/// -/// This is a class used by the tests which verify that the custom callback -/// functions can be installed to unpack options from a message. When the -/// callback function is called, the executed_ member is set to true to allow -/// verification that the callback was really called. Internally, this class -/// uses libdhcp++ to unpack options so the options parsing algorithm remains -/// unchanged after installation of the callback. -class CustomUnpackCallback { -public: - - /// @brief Constructor - /// - /// Marks that callback hasn't been called. - CustomUnpackCallback() - : executed_(false) { - } - - /// @brief A callback - /// - /// Contains custom implementation of the callback. - /// - /// @param buf a A buffer holding options in on-wire format. - /// @param option_space A name of the option space being encapsulated by - /// the option being parsed. - /// @param [out] options A reference to the collection where parsed options - /// will be stored. - /// @return An offset to the first byte after last parsed option. - size_t execute(const OptionBuffer& buf, - const std::string& option_space, - isc::dhcp::OptionCollection& options) { - // Set the executed_ member to true to allow verification that the - // callback has been actually called. - executed_ = true; - // Use default implementation of the unpack algorithm to parse options. - return (LibDHCP::unpackOptions4(buf, option_space, options)); - } - - /// A flag which indicates if callback function has been called. - bool executed_; -}; - /// V4 Options being used for pack/unpack testing. /// For test simplicity, all selected options have /// variable length data so as there are no restrictions @@ -766,47 +724,6 @@ TEST_F(Pkt4Test, unpackVendorMalformed) { EXPECT_THROW(too_short_pkt->unpack(), InvalidOptionValue); } -// This test verifies that it is possible to specify custom implementation of -// the option parsing algorithm by installing a callback function. -TEST_F(Pkt4Test, unpackOptionsWithCallback) { - vector expectedFormat = generateTestPacket2(); - - expectedFormat.push_back(0x63); - expectedFormat.push_back(0x82); - expectedFormat.push_back(0x53); - expectedFormat.push_back(0x63); - - for (size_t i = 0; i < sizeof(v4_opts); i++) { - expectedFormat.push_back(v4_opts[i]); - } - - // now expectedFormat contains fixed format and 5 options - - boost::shared_ptr pkt(new Pkt4(&expectedFormat[0], - expectedFormat.size())); - - CustomUnpackCallback cb; - pkt->setCallback(boost::bind(&CustomUnpackCallback::execute, &cb, - _1, _2, _3)); - - ASSERT_FALSE(cb.executed_); - - EXPECT_NO_THROW(pkt->unpack()); - - EXPECT_TRUE(cb.executed_); - verifyParsedOptions(pkt); - - // Reset the indicator to perform another check: uninstall the callback. - cb.executed_ = false; - // By setting the callback to NULL we effectively uninstall the callback. - pkt->setCallback(NULL); - // Do another unpack. - EXPECT_NO_THROW(pkt->unpack()); - // Callback should not be executed. - EXPECT_FALSE(cb.executed_); - -} - // This test verifies methods that are used for manipulating meta fields // i.e. fields that are not part of DHCPv4 (e.g. interface name). TEST_F(Pkt4Test, metaFields) { diff --git a/src/lib/dhcp/tests/pkt6_unittest.cc b/src/lib/dhcp/tests/pkt6_unittest.cc index fa7c750e09..21e4de0183 100644 --- a/src/lib/dhcp/tests/pkt6_unittest.cc +++ b/src/lib/dhcp/tests/pkt6_unittest.cc @@ -41,55 +41,6 @@ using boost::scoped_ptr; namespace { -/// @brief A class which contains a custom callback function to unpack options. -/// -/// This is a class used by the tests which verify that the custom callback -/// functions can be installed to unpack options from a message. When the -/// callback function is called, the executed_ member is set to true to allow -/// verification that the callback was really called. Internally, this class -/// uses libdhcp++ to unpack options so the options parsing algorithm remains -/// unchanged after installation of the callback. -class CustomUnpackCallback { -public: - - /// @brief Constructor - /// - /// Marks that callback hasn't been called. - CustomUnpackCallback() - : executed_(false) { - } - - /// @brief A callback - /// - /// Contains custom implementation of the callback. - /// - /// @param buf a A buffer holding options in on-wire format. - /// @param option_space A name of the option space encapsulated by the - /// option being parsed. - /// @param [out] options A reference to the collection where parsed options - /// will be stored. - /// @param relay_msg_offset Reference to a size_t structure. If specified, - /// offset to beginning of relay_msg option will be stored in it. - /// @param relay_msg_len reference to a size_t structure. If specified, - /// length of the relay_msg option will be stored in it. - /// @return An offset to the first byte after last parsed option. - size_t execute(const OptionBuffer& buf, - const std::string& option_space, - isc::dhcp::OptionCollection& options, - size_t* relay_msg_offset, - size_t* relay_msg_len) { - // Set the executed_ member to true to allow verification that the - // callback has been actually called. - executed_ = true; - // Use default implementation of the unpack algorithm to parse options. - return (LibDHCP::unpackOptions6(buf, option_space, options, - relay_msg_offset, relay_msg_len)); - } - - /// A flag which indicates if callback function has been called. - bool executed_; -}; - class Pkt6Test : public ::testing::Test { public: Pkt6Test() { @@ -436,49 +387,6 @@ TEST_F(Pkt6Test, unpackVendorMalformed) { EXPECT_THROW(too_short_option_pkt->unpack(), OutOfRange); } -// This test verifies that it is possible to specify custom implementation of -// the option parsing algorithm by installing a callback function. -TEST_F(Pkt6Test, packUnpackWithCallback) { - // Create an on-wire representation of the test packet and clone it. - Pkt6Ptr pkt(new Pkt6(DHCPV6_SOLICIT, 0x020304)); - Pkt6Ptr clone = packAndClone(pkt); - - // Install the custom callback function. We expect that this function - // will be called to parse options in the packet instead of - // LibDHCP::unpackOptions6. - CustomUnpackCallback cb; - clone->setCallback(boost::bind(&CustomUnpackCallback::execute, &cb, - _1, _2, _3, _4, _5)); - // Make sure that the flag which indicates if the callback function has - // been called is not set. Otherwise, our test doesn't make sense. - ASSERT_FALSE(cb.executed_); - - // Now recreate options list - ASSERT_NO_THROW(clone->unpack()); - - // An object which holds a callback should now have a flag set which - // indicates that callback has been called. - EXPECT_TRUE(cb.executed_); - - // transid, message-type should be the same as before - EXPECT_EQ(0x020304, clone->getTransid()); - EXPECT_EQ(DHCPV6_SOLICIT, clone->getType()); - - EXPECT_TRUE(clone->getOption(1)); - EXPECT_TRUE(clone->getOption(2)); - EXPECT_TRUE(clone->getOption(100)); - EXPECT_FALSE(clone->getOption(4)); - - // Reset the indicator to perform another check: uninstall the callback. - cb.executed_ = false; - // By setting the callback to NULL we effectively uninstall the callback. - clone->setCallback(NULL); - // Do another unpack. - ASSERT_NO_THROW(clone->unpack()); - // Callback should not be executed. - EXPECT_FALSE(cb.executed_); -} - // This test verifies that options can be added (addOption()), retrieved // (getOption(), getOptions()) and deleted (delOption()). TEST_F(Pkt6Test, addGetDelOptions) {