Commit beeadf3d authored by mayya's avatar mayya Committed by Tomek Mrugalski
Browse files

[lib] Address review comments for #83

 See  #88 for review comments

modified upgrade files

modified tests
parent 2090af48
......@@ -374,7 +374,7 @@ private:
cass_int32_t reserved_ipv6_prefix_address_type_;
/// @brief Key for authentication
std::string reserved_key_;
std::string key_;
/// @brief The reservation's IAID
cass_int32_t iaid_;
......@@ -825,7 +825,7 @@ CqlHostExchange::createBindForSelect(AnyArray& data, StatementTag /* not used */
// reserved_ipv6_prefix_address_type: int
data.add(&reserved_ipv6_prefix_address_type_);
// reserved_key: text
data.add(&reserved_key_);
data.add(&key_);
// iaid: int
data.add(&iaid_);
/// @}
......@@ -959,7 +959,7 @@ CqlHostExchange::prepareExchange(const HostPtr& host,
reservation->getType() == IPv6Resrv::TYPE_NA ? 0 : 2;
// reserved_key: text
reserved_key_ = reservation->getKeys();
key_ = reservation->getKey().getAuthKey();
// iaid: int
/// @todo: We don't support iaid in the IPv6Resrv yet.
......@@ -1080,7 +1080,7 @@ CqlHostExchange::createBindForMutation(const HostPtr& host,
data.add(&reserved_ipv6_prefix_address_);
data.add(&reserved_ipv6_prefix_length_);
data.add(&reserved_ipv6_prefix_address_type_);
data.add(&reserved_key_);
data.add(&key_);
data.add(&iaid_);
// Option
......@@ -1248,7 +1248,7 @@ CqlHostExchange::retrieveReservation() const {
}
return (IPv6Resrv(type, IOAddress(reserved_ipv6_prefix_address_),
reserved_ipv6_prefix_length_, reserved_key_));
reserved_ipv6_prefix_length_, key_));
}
const OptionWrapper
......
......@@ -21,29 +21,69 @@ using namespace isc::asiolink;
namespace isc {
namespace dhcp {
AuthKey::AuthKey(const std::string key) {
setAuthKey(key);
}
AuthKey::AuthKey(void) {
authKey_ = AuthKey::getRandomKeyString();
}
std::string
AuthKey::getRandomKeyString() {
std::array <char, AuthKey::KEY_LEN> randomString;
std::random_device rd;
boost::random::mt19937 gen(rd());
std::for_each(randomString.begin(), randomString.end() - 1,
[&gen](char& a){ boost::random::uniform_int_distribution<char> dist('!', '~');
a = dist(gen); } );
return std::string(randomString.begin(), randomString.end());
}
void
AuthKey::setAuthKey(const std::string& key) {
authKey_ = key;
if (authKey_.size() > AuthKey::KEY_LEN) {
authKey_.resize(AuthKey::KEY_LEN);
}
}
bool
AuthKey::operator==(const AuthKey& other) const {
return (authKey_ == other.authKey_);
}
bool
AuthKey::operator!=(const AuthKey& other) const {
return (authKey_ != other.authKey_);
}
IPv6Resrv::IPv6Resrv(const Type& type,
const asiolink::IOAddress& prefix,
const uint8_t prefix_len)
: type_(type), prefix_(asiolink::IOAddress("::")),
prefix_len_(128), keys_("") {
prefix_len_(128), key_("") {
// Validate and set the actual values.
set(type, prefix, prefix_len);
}
IPv6Resrv::IPv6Resrv(const Type& type,
const asiolink::IOAddress& prefix,
const std::string& keys,
const AuthKey& key,
const uint8_t prefix_len)
: type_(type), prefix_(asiolink::IOAddress("::")),
prefix_len_(128), keys_("") {
prefix_len_(128), key_("") {
// Validate and set the actual values.
set(type, prefix, prefix_len, keys);
set(type, prefix, prefix_len, key);
}
void
IPv6Resrv::set(const Type& type, const asiolink::IOAddress& prefix,
const uint8_t prefix_len, const std::string& keys) {
const uint8_t prefix_len, const AuthKey& key) {
if (!prefix.isV6() || prefix.isV6Multicast()) {
isc_throw(isc::BadValue, "invalid prefix '" << prefix
<< "' for new IPv6 reservation");
......@@ -57,37 +97,22 @@ IPv6Resrv::set(const Type& type, const asiolink::IOAddress& prefix,
isc_throw(isc::BadValue, "invalid prefix length '"
<< static_cast<int>(prefix_len)
<< "' for reserved IPv6 address, expected 128");
} else if (!keys.empty()) {
//Don't overwrite with an empty string
keys_ = keys;
}
if ( key.getAuthKey().size() != 0 ) {
key_ = key;
}
type_ = type;
prefix_ = prefix;
prefix_len_ = prefix_len;
}
std::string
IPv6Resrv::getRandomKeyString()
{
std::array <char, 128> randomString;
std::random_device rd;
boost::random::mt19937 gen(rd());
std::for_each(randomString.begin(), randomString.end() - 1,
[&gen](char& a){ boost::random::uniform_int_distribution<char> dist('!', '~');
a = dist(gen); } );
return std::string(randomString.begin(), randomString.end());
}
std::string
IPv6Resrv::toText() const {
std::ostringstream s;
s << prefix_;
// For PD, append prefix length.
// @todo: add to text for keys
// @todo: add to text for key
if (getType() == TYPE_PD) {
s << "/" << static_cast<int>(prefix_len_);
}
......@@ -99,7 +124,7 @@ IPv6Resrv::operator==(const IPv6Resrv& other) const {
return (type_ == other.type_ &&
prefix_ == other.prefix_ &&
prefix_len_ == other.prefix_len_ &&
keys_ == other.keys_ );
key_ == other.key_ );
}
bool
......
......@@ -27,6 +27,70 @@ namespace dhcp {
/// @brief HostID (used only when storing in MySQL, PostgreSQL or Cassandra)
typedef uint64_t HostID;
/// @brief Authentication keys
///
/// This class represents authentication keys to be used for
/// calculating HMAC in the authentication field of the recofigure message
class AuthKey {
public:
/// @brief Length of the key - 128 bits
const static uint8_t KEY_LEN = 16;
/// @brief Constructor
///
/// Constructor for assigning auth keys in host reservation
/// Throws if the key length is greater than 16 bytes
/// appends 0 to the the input if the key value is less
/// than 16 bytes. Provide flexibility to store initialise the value as a string or a vector of bytes.
/// @param string auth key to be stored
AuthKey(const std::string key);
/// @brief Constructor
///
/// Constructor for generating auth keys, with no argument
/// shall use the internal function for generationg random keys
AuthKey(void);
// @brief get random string
///
/// Random string is generated by default will be used for
/// the keys to be used for signing Reconfigure Message.
/// @return auth keys
/// @todo Move randomization function to cryptolink
static std::string getRandomKeyString();
/// @brief get auth key value
///
/// Returns 16 Byte long key
std::string getAuthKey() const {
return authKey_;
}
/// @brief set auth key value
///
/// Set the key value. If the value is less than 16 bytes
/// append 0. If the size is greater than 16 bytes, we shall
/// throw an exception
/// @param string key to be stored
void setAuthKey(const std::string& key);
/// @brief equality operator
///
/// equality operator to compare two AuthKey classes
/// @param Authkey to be compared against
bool operator==(const AuthKey& other) const;
/// @brief inequality operator
///
/// inequality operator to compare two AuthKey classes
/// @param Authkey to be compared against
bool operator!=(const AuthKey& other) const;
private:
std::string authKey_;
};
/// @brief IPv6 reservation for a host.
///
/// This class represents a reservation for a host of a single IPv6
......@@ -79,7 +143,7 @@ public:
/// multicast address or the prefix length is greater than 128.
IPv6Resrv(const Type& type,
const asiolink::IOAddress& prefix,
const std::string& keys,
const AuthKey& key,
const uint8_t prefix_len = 128);
/// @brief Returns prefix for the reservation.
......@@ -101,12 +165,19 @@ public:
return (type_);
}
/// @brief Returns the keys.
/// @brief Returns the key.
///
/// Keys are used for signing the Reconfigure Message.
AuthKey getKey() const {
return(key_);
}
/// @brief sets key.
///
/// Keys are used for signing the Reconfigure Message.
/// The accessor should ensure 128 characters
std::string getKeys() const {
return (keys_);
void setKey(const AuthKey& key) {
key_ = key;
}
/// @brief Sets a new prefix and prefix length.
......@@ -118,18 +189,11 @@ public:
/// @throw isc::BadValue if prefix is not IPv6 prefix, is a
/// multicast address or the prefix length is greater than 128.
void set(const Type& type, const asiolink::IOAddress& prefix,
const uint8_t prefix_len, const std::string& keys = "");
const uint8_t prefix_len, const AuthKey& key = std::string(""));
/// @brief Returns information about the reservation in the textual format.
std::string toText() const;
/// @brief Generates random 128 bit string
///
/// Random string is generated by default will be used for
/// the keys to be used for signing Reconfigure Message.
static std::string getRandomKeyString();
/// @brief Equality operator.
///
/// @param other Reservation to compare to.
......@@ -145,8 +209,7 @@ private:
Type type_; ///< Reservation type.
asiolink::IOAddress prefix_; ///< Prefix
uint8_t prefix_len_; ///< Prefix length.
std::string keys_; ///< keys for authentication.
AuthKey key_; ///< keys for authentication.
};
/// @brief Collection of IPv6 reservations for the host.
......
......@@ -74,7 +74,7 @@ const size_t SERVER_HOSTNAME_MAX_LEN = 64;
const size_t BOOT_FILE_NAME_MAX_LEN = 128;
/// @brief Maximum length of keys.
const size_t KEY_MAX_LEN = 128;
const size_t KEY_LEN = 16;
/// @brief Numeric value representing last supported identifier.
/// @brief Numeric value representing last supported identifier.
......@@ -1537,7 +1537,7 @@ private:
uint32_t iaid_;
/// @brief Buffer length for holding keys in textual format.
char key_buffer_[KEY_MAX_LEN + 1];
char key_buffer_[KEY_LEN + 1];
/// @brief Length of the keys
unsigned long key_len_;
......@@ -1671,7 +1671,7 @@ public:
// key VARCHAR(128)
// why we need member for len
key_ = resv.getKeys();
key_ = resv.getKey().getAuthKey();
key_len_ = key_.length();
bind_[5].buffer_type = MYSQL_TYPE_BLOB;
bind_[5].buffer = reinterpret_cast<char*>
......
......@@ -877,7 +877,7 @@ public:
columns_[iaid_index_] = "dhcp6_iaid";
columns_[key_index_] = "auth_key";
BOOST_STATIC_ASSERT(4 < RESERVATION_COLUMNS);
BOOST_STATIC_ASSERT(5 < RESERVATION_COLUMNS);
}
/// @brief Reinitializes state information
......@@ -946,7 +946,7 @@ public:
// getColumnValue(r, row, iaid_index_, iaid);
// Create the reservation.
IPv6Resrv reservation(resv_type, IOAddress(address), key, prefix_len);
IPv6Resrv reservation(resv_type, IOAddress(address), AuthKey(key), prefix_len);
return (reservation);
};
......@@ -1090,12 +1090,11 @@ public:
/// @todo: We don't support iaid in the IPv6Resrv yet.
bind_array->addNull();
// type: VARCHAR(16) NULL
bind_array->add(resv.getKey().getAuthKey());
// host_id: BIGINT NOT NULL
bind_array->add(host_id);
// type: VARCHAR(128) NOT NULL
bind_array->add(resv.getKeys());
} catch (const std::exception& ex) {
isc_throw(DbOperationError,
"Could not create bind array from IPv6 Reservation: "
......@@ -1637,10 +1636,10 @@ TaggedStatementArray tagged_statements = { {
//PgSqlHostDataSourceImpl::INSERT_V6_RESRV
// Inserts a single IPv6 reservation into 'reservations' table.
{6,
{ OID_VARCHAR, OID_INT2, OID_INT4, OID_INT4, OID_INT4 },
{ OID_VARCHAR, OID_INT2, OID_INT4, OID_INT4, OID_VARCHAR, OID_INT4},
"insert_v6_resrv",
"INSERT INTO ipv6_reservations(address, prefix_len, type, "
" dhcp6_iaid, host_id, auth_key) "
" dhcp6_iaid, auth_key, host_id) "
"VALUES ($1, $2, $3, $4, $5, $6)"
},
......
......@@ -35,14 +35,15 @@ TEST(IPv6ResrvTest, constructorAddress) {
EXPECT_EQ("2001:db8:1::cafe", resrv.getPrefix().toText());
EXPECT_EQ(128, resrv.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
EXPECT_EQ("", resrv.getKeys());
EXPECT_EQ("", resrv.getKey().getAuthKey());
//create reservation with keys
IPv6Resrv resrv_keys(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::cafe"), "#ssd@@dce3");
std::string key = "#ssd@@dce3";
IPv6Resrv resrv_keys(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::cafe"), AuthKey(key));
EXPECT_EQ("2001:db8:1::cafe", resrv_keys.getPrefix().toText());
EXPECT_EQ(128, resrv_keys.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_NA, resrv_keys.getType());
EXPECT_EQ("#ssd@@dce3", resrv_keys.getKeys());
EXPECT_EQ(key, resrv_keys.getKey().getAuthKey());
}
// This test verifies that it is possible to create IPv6 prefix
......@@ -52,14 +53,15 @@ TEST(IPv6ResrvTest, constructorPrefix) {
EXPECT_EQ("2001:db8:1::", resrv.getPrefix().toText());
EXPECT_EQ(64, resrv.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_PD, resrv.getType());
EXPECT_EQ("", resrv.getKeys());
EXPECT_EQ("", resrv.getKey().getAuthKey());
//create reservation with keys
IPv6Resrv resrv_keys(IPv6Resrv::TYPE_PD, IOAddress("2001:db8:1::"), "#ssd@@dce3", 64);
std::string key = "#ssd@@dce3";
IPv6Resrv resrv_keys(IPv6Resrv::TYPE_PD, IOAddress("2001:db8:1::"), AuthKey(key), 64);
EXPECT_EQ("2001:db8:1::", resrv_keys.getPrefix().toText());
EXPECT_EQ(64, resrv_keys.getPrefixLen());
EXPECT_EQ(IPv6Resrv::TYPE_PD, resrv_keys.getType());
EXPECT_EQ("#ssd@@dce3", resrv_keys.getKeys());
EXPECT_EQ(key, resrv_keys.getKey().getAuthKey());
}
// This test verifies that the toText() function prints correctly.
......@@ -128,21 +130,16 @@ TEST(IPv6ResrvTest, setKeys) {
ASSERT_EQ("2001:db8:1::1", resrv.getPrefix().toText());
ASSERT_EQ(128, resrv.getPrefixLen());
ASSERT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
ASSERT_EQ("", resrv.getKeys());
// Replace default keys with new value.
resrv.set(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::1"), 128, "first_set_keys_#");
ASSERT_EQ("2001:db8:1::1", resrv.getPrefix().toText());
ASSERT_EQ(128, resrv.getPrefixLen());
ASSERT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
ASSERT_EQ("first_set_keys_#", resrv.getKeys());
ASSERT_EQ("", resrv.getKey().getAuthKey());
// Modify an existing key for the reservation
resrv.set(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::1"), 128, "second_set_keys_#");
std::string key2 = "key2";
resrv.set(IPv6Resrv::TYPE_NA, IOAddress("2001:db8:1::1"),
128, AuthKey(key2));
ASSERT_EQ("2001:db8:1::1", resrv.getPrefix().toText());
ASSERT_EQ(128, resrv.getPrefixLen());
ASSERT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
ASSERT_EQ("second_set_keys_#", resrv.getKeys());
ASSERT_EQ(key2, resrv.getKey().getAuthKey());
// Enusre not including the key parameter won't affect
// the current configured keys
......@@ -150,7 +147,7 @@ TEST(IPv6ResrvTest, setKeys) {
ASSERT_EQ("2001:db8:1::1", resrv.getPrefix().toText());
ASSERT_EQ(128, resrv.getPrefixLen());
ASSERT_EQ(IPv6Resrv::TYPE_NA, resrv.getType());
ASSERT_EQ("second_set_keys_#", resrv.getKeys());
ASSERT_EQ(key2, resrv.getKey().getAuthKey());
}
// This test checks that the equality operators work fine.
......@@ -182,22 +179,22 @@ TEST(IPv6ResrvTest, equal) {
IPv6Resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::1"), 128));
EXPECT_TRUE(IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::1"),
"key##1", 128) ==
AuthKey("key##1"), 128) ==
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::1"),
"key##1", 128));
AuthKey("key##1"), 128));
EXPECT_FALSE(IPv6Resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::1"),
"key##1", 128) !=
AuthKey("key##1"), 128) !=
IPv6Resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::1"),
"key##1", 128));
AuthKey("key##1"), 128));
EXPECT_FALSE(IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::1"),
"key##1", 128) ==
AuthKey("key##1"), 128) ==
IPv6Resrv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::1"),
"key##2", 128));
AuthKey("key##2"), 128));
EXPECT_TRUE(IPv6Resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::1"),
"key##1", 128) !=
AuthKey("key##1"), 128) !=
IPv6Resrv(IPv6Resrv::TYPE_PD, IOAddress("2001:db8::1"),
"key##2", 128));
AuthKey("key##2"), 128));
}
/// @brief Test fixture class for @c Host.
......@@ -678,9 +675,9 @@ TEST_F(HostTest, addReservations) {
// Add 4 reservations: 2 for NAs, 2 for PDs
ASSERT_NO_THROW(
host->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::cafe"), "key##1"));
IOAddress("2001:db8:1::cafe"), AuthKey("key##1")));
host->addReservation(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:1::"), "key##2", 64));
IOAddress("2001:db8:1:1::"), AuthKey("key##2"), 64));
host->addReservation(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:2::"), 64));
host->addReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
......@@ -691,9 +688,9 @@ TEST_F(HostTest, addReservations) {
// Check that reservations exist.
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::cafe"), "key##1")));
IOAddress("2001:db8:1::cafe"), AuthKey("key##1"))));
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:1::"), "key##2",
IOAddress("2001:db8:1:1::"), AuthKey("key##2"),
64)));
EXPECT_TRUE(host->hasReservation(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:2::"),
......@@ -705,7 +702,7 @@ TEST_F(HostTest, addReservations) {
IPv6ResrvRange addresses = host->getIPv6Reservations(IPv6Resrv::TYPE_NA);
ASSERT_EQ(2, std::distance(addresses.first, addresses.second));
EXPECT_TRUE(reservationExists(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::cafe"), "key##1"),
IOAddress("2001:db8:1::cafe"), AuthKey("key##1")),
addresses));
EXPECT_TRUE(reservationExists(IPv6Resrv(IPv6Resrv::TYPE_NA,
IOAddress("2001:db8:1::1")),
......@@ -716,7 +713,7 @@ TEST_F(HostTest, addReservations) {
IPv6ResrvRange prefixes = host->getIPv6Reservations(IPv6Resrv::TYPE_PD);
ASSERT_EQ(2, std::distance(prefixes.first, prefixes.second));
EXPECT_TRUE(reservationExists(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:1::"),"key##2", 64),
IOAddress("2001:db8:1:1::"), AuthKey("key##2"), 64),
prefixes));
EXPECT_TRUE(reservationExists(IPv6Resrv(IPv6Resrv::TYPE_PD,
IOAddress("2001:db8:1:2::"), 64),
......@@ -1291,7 +1288,7 @@ TEST_F(HostTest, randomKeys) {
key_map.reserve(max_hash_size);
for (iter_num = 0; iter_num < max_iter; iter_num++) {
std::string key = IPv6Resrv::getRandomKeyString();
std::string key = AuthKey::getRandomKeyString();
if (key_map[key]) {
dup_element++;
break;
......@@ -1303,6 +1300,31 @@ TEST_F(HostTest, randomKeys) {
EXPECT_EQ(0, dup_element);
}
//Test performs basic functionality test of the AuthKey class
TEST(AuthKeyTest, basicTest) {
//call the constructor with default argument
// Default constructor should generate random string of 16 bytes
AuthKey defaultKey;
ASSERT_EQ(16, defaultKey.getAuthKey().size());
AuthKey longKey("someRandomStringGreaterThan16Bytes");
ASSERT_EQ(16, longKey.getAuthKey().size());
//check the setters for valid and invalid string
std::string key16ByteStr = "0123456789abcdef";
std::string key18ByteStr = "0123456789abcdefgh";
AuthKey defaultTestKey;
defaultTestKey.setAuthKey(key16ByteStr);
ASSERT_EQ(16, defaultTestKey.getAuthKey().size());
ASSERT_EQ(key16ByteStr, defaultTestKey.getAuthKey());
defaultTestKey.setAuthKey(key18ByteStr);
ASSERT_EQ(16, defaultTestKey.getAuthKey().size());
ASSERT_EQ(key16ByteStr, defaultTestKey.getAuthKey());
}
} // end of anonymous namespace
......
......@@ -897,7 +897,7 @@ GenericHostDataSourceTest::testAddr6AndPrefix() {
true, "key##1", true);
// Create IPv6 reservation (for an address) and add it to the host
IPv6Resrv resv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::2"), "key##2", 128);
IPv6Resrv resv(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::2"), AuthKey("key##2"), 128);
host->addReservation(resv);
// Add this reservation
......@@ -925,10 +925,10 @@ GenericHostDataSourceTest::testMultipleReservations() {
HostPtr host = HostDataSourceUtils::initializeHost6("2001:db8::1", Host::IDENT_DUID, false);
// Add some reservations
IPv6Resrv resv1(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::6"), "key##1", len);
IPv6Resrv resv2(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::7"), "key##2", len);
IPv6Resrv resv3(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::8"), "key##3", len);
IPv6Resrv resv4(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::9"), "key##4", len);
IPv6Resrv resv1(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::6"), AuthKey("key##1"), len);
IPv6Resrv resv2(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::7"), AuthKey("key##2"), len);
IPv6Resrv resv3(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::8"), AuthKey("key##3"), len);
IPv6Resrv resv4(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::9"), AuthKey("key##4"), len);
host->addReservation(resv1);
host->addReservation(resv2);
......@@ -956,10 +956,10 @@ GenericHostDataSourceTest::testMultipleReservationsDifferentOrder() {
HostPtr host2 = HostDataSourceUtils::initializeHost6("2001:db8::1", Host::IDENT_DUID, false);
// Add some reservations
IPv6Resrv resv1(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::6"), "key##1", len);
IPv6Resrv resv2(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::7"), "key##2", len);
IPv6Resrv resv3(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::8"), "key##3", len);
IPv6Resrv resv4(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::9"), "key##4", len);
IPv6Resrv resv1(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::6"), AuthKey("key##1"), len);
IPv6Resrv resv2(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::7"), AuthKey("key##2"), len);
IPv6Resrv resv3(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::8"), AuthKey("key##3"), len);
IPv6Resrv resv4(IPv6Resrv::TYPE_NA, IOAddress("2001:db8::9"), AuthKey("key##4"), len);
host1->addReservation(resv1);
host1->addReservation(resv2);
......
......@@ -112,11 +112,11 @@ HostDataSourceUtils::initializeHost6(const std::string address,
if (!prefix) {
// Create IPv6 reservation (for an address)
IPv6Resrv resv(IPv6Resrv::TYPE_NA, IOAddress(address), key, 128);
IPv6Resrv resv(IPv6Resrv::TYPE_NA, IOAddress(address), AuthKey(key), 128);