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_;
// 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_);
/// @}
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.
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
}
return (IPv6Resrv(type, IOAddress(reserved_ipv6_prefix_address_),
- reserved_ipv6_prefix_length_, reserved_key_));
+ reserved_ipv6_prefix_length_, key_));
}
const OptionWrapper
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");
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_);
}
return (type_ == other.type_ &&
prefix_ == other.prefix_ &&
prefix_len_ == other.prefix_len_ &&
- keys_ == other.keys_ );
+ key_ == other.key_ );
}
bool
/// @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
/// 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.
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.
/// @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.
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.
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.
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_;
// 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*>
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
// 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);
};
/// @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: "
//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)"
},
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
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.
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
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.
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.
// 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,
// 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::"),
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")),
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),
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;
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
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
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);
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);
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);
host->addReservation(resv);
} else {
// Create IPv6 reservation for a /64 prefix
- IPv6Resrv resv(IPv6Resrv::TYPE_PD, IOAddress(address), key, 64);
+ IPv6Resrv resv(IPv6Resrv::TYPE_PD, IOAddress(address), AuthKey(key), 64);
host->addReservation(resv);
}
return (host);
-- Create search index for logs table
CREATE INDEX IF NOT EXISTS logsindex ON logs (address);
+-- Add new field.
+ALTER TABLE host_reservations ADD reserved_auth_key text;
+
-- Cql requires primary keys in the WHERE here.
DELETE FROM schema_version WHERE version=2;
INSERT INTO schema_version (version, minor) VALUES(3, 0);
-
+>>>>>>> [lib] Address review comments for #83
-- This line concludes database upgrade to version 3.0
CREATE INDEX IF NOT EXISTS logsindex ON logs (address);
-- Cql requires primary keys in the WHERE here.
+ALTER TABLE host_reservations ADD reserved_auth_key text;
+
DELETE FROM schema_version WHERE version=2;
INSERT INTO schema_version (version, minor) VALUES(3, 0);
prefix_len TINYINT(3) UNSIGNED NOT NULL DEFAULT 128,
type TINYINT(4) UNSIGNED NOT NULL DEFAULT 0,
dhcp6_iaid INT UNSIGNED NULL,
- auth_key VARCHAR(128) NOT NULL,
host_id INT UNSIGNED NOT NULL,
PRIMARY KEY (reservation_id),
INDEX fk_ipv6_reservations_host_idx (host_id ASC),
ALTER TABLE ipv6_reservations
MODIFY reservation_id INT UNSIGNED NOT NULL AUTO_INCREMENT;
+# This line concludes database upgrade to version 7.0.
+
# Add columns holding reservations for siaddr, sname and file fields
# carried within DHCPv4 message.
ALTER TABLE hosts ADD COLUMN dhcp4_next_server INT UNSIGNED NULL;
# Create search index
CREATE INDEX timestamp_index ON logs (timestamp);
+#add auth key for reconfiguration
+ALTER TABLE ipv6_reservations
+ ADD COLUMN auth_key VARCHAR(16) NULL;
+
# Update the schema version number
UPDATE schema_version
SET version = '7', minor = '0';
# Create search index
CREATE INDEX timestamp_index ON logs (timestamp);
+#add auth key for reconfiguration
+ALTER TABLE ipv6_reservations
+ ADD COLUMN auth_key VARCHAR(16) NULL;
+
# Update the schema version number
UPDATE schema_version
SET version = '7', minor = '0';
prefix_len SMALLINT NOT NULL DEFAULT '128',
type SMALLINT NOT NULL DEFAULT '0',
dhcp6_iaid INT DEFAULT NULL,
- auth_key VARCHAR(128) NOT NULL,
host_id INT NOT NULL,
CONSTRAINT key_dhcp6_address_prefix_len UNIQUE (address, prefix_len),
CONSTRAINT fk_ipv6_reservations_host FOREIGN KEY (host_id) REFERENCES hosts (host_id) ON DELETE CASCADE
CREATE INDEX timestamp_id ON logs (timestamp);
CREATE INDEX address_id ON logs (address);
--- Set 5.0 schema version.
+-- Create auth_key in ipv6_reservations
+ALTER TABLE ipv6_reservations ADD COLUMN auth_key VARCHAR(26) DEFAULT NULL;
+
+-- Set schema 5.0 version
UPDATE schema_version
- SET version = '5', minor = '0';
+ SET version = '5', minor = '0';
-- Schema 5.0 specification ends here.
CREATE INDEX timestamp_id ON logs (timestamp);
CREATE INDEX address_id ON logs (address);
+-- Create auth_key in ipv6_reservations
+ALTER TABLE ipv6_reservations ADD COLUMN auth_key VARCHAR(16) DEFAULT NULL;
+
-- Set 5.0 schema version.
UPDATE schema_version
SET version = '5', minor = '0';
projects / thirdparty / kea.git / commitdiff
