[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.

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

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<unsigned int, OptionPtr> OptionCollection;
 /// A pointer to an OptionCollection
 typedef boost::shared_ptr<OptionCollection> 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)
 };

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<uint8_t>(u, type, begin, end) :
                     factoryInteger<uint8_t>(u, type, getEncapsulatedSpace(),
-                                            begin, end, callback));
+                                            begin, end));
 
         case OPT_INT8_TYPE:
             return (array_type_ ?
                     factoryIntegerArray<int8_t>(u, type, begin, end) :
                     factoryInteger<int8_t>(u, type, getEncapsulatedSpace(),
-                                           begin, end, callback));
+                                           begin, end));
 
         case OPT_UINT16_TYPE:
             return (array_type_ ?
                     factoryIntegerArray<uint16_t>(u, type, begin, end) :
                     factoryInteger<uint16_t>(u, type, getEncapsulatedSpace(),
-                                             begin, end, callback));
+                                             begin, end));
 
         case OPT_INT16_TYPE:
             return (array_type_ ?
                     factoryIntegerArray<uint16_t>(u, type, begin, end) :
                     factoryInteger<int16_t>(u, type, getEncapsulatedSpace(),
-                                            begin, end, callback));
+                                            begin, end));
 
         case OPT_UINT32_TYPE:
             return (array_type_ ?
                     factoryIntegerArray<uint32_t>(u, type, begin, end) :
                     factoryInteger<uint32_t>(u, type, getEncapsulatedSpace(),
-                                             begin, end, callback));
+                                             begin, end));
 
         case OPT_INT32_TYPE:
             return (array_type_ ?
                     factoryIntegerArray<uint32_t>(u, type, begin, end) :
                     factoryInteger<int32_t>(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()) {

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<T>(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.

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.

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

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

src/lib/dhcp/tests/option_definition_unittest.cc

@@ -1242,7 +1242,7 @@ TEST_F(OptionDefinitionTest, integerInvalidType) {
     OptionBuffer buf(1);
     EXPECT_THROW(
         OptionDefinition::factoryInteger<bool>(Option::V6, D6O_PREFERENCE, "dhcp6",
-                                               buf.begin(), buf.end(), NULL),
+                                               buf.begin(), buf.end()),
         isc::dhcp::InvalidDataType
     );
 }

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

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<uint8_t> 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<Pkt4> 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) {

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