25 AuthKey::AuthKey(
const std::vector<uint8_t>& key) {
29 AuthKey::AuthKey(
const std::string& key) {
34 authKey_ = AuthKey::getRandomKeyString();
38 AuthKey::getRandomKeyString() {
43 AuthKey::toText()
const {
44 if (authKey_.empty()) {
51 AuthKey::setAuthKey(
const std::vector<uint8_t>& key) {
59 AuthKey::setAuthKey(
const std::string& key) {
65 std::vector<uint8_t> bin;
68 }
catch (
const std::exception& ex) {
75 return (authKey_ == other.authKey_);
80 return (authKey_ != other.authKey_);
83 IPv6Resrv::IPv6Resrv(
const Type& type,
85 const uint8_t prefix_len)
88 set(type, prefix, prefix_len);
93 const uint8_t prefix_len) {
96 <<
"' for new IPv6 reservation");
98 }
else if (prefix_len > 128) {
100 <<
static_cast<int>(prefix_len)
101 <<
"' for new IPv6 reservation");
103 }
else if ((type ==
TYPE_NA) && (prefix_len != 128)) {
105 <<
static_cast<int>(prefix_len)
106 <<
"' for reserved IPv6 address, expected 128");
111 prefix_len_ = prefix_len;
116 std::ostringstream s;
120 s <<
"/" <<
static_cast<int>(prefix_len_);
127 return (type_ == other.type_ &&
128 prefix_ == other.prefix_ &&
129 prefix_len_ == other.prefix_len_);
134 return (!
operator==(other));
137 Host::Host(
const uint8_t* identifier,
const size_t identifier_len,
141 const std::string& hostname,
142 const std::string& dhcp4_client_classes,
143 const std::string& dhcp6_client_classes,
145 const std::string& server_host_name,
146 const std::string& boot_file_name,
149 : identifier_type_(identifier_type),
150 identifier_value_(), ipv4_subnet_id_(ipv4_subnet_id),
151 ipv6_subnet_id_(ipv6_subnet_id),
153 hostname_(hostname), dhcp4_client_classes_(dhcp4_client_classes),
154 dhcp6_client_classes_(dhcp6_client_classes),
156 server_host_name_(server_host_name), boot_file_name_(boot_file_name),
157 host_id_(0), cfg_option4_(new
CfgOption()),
158 cfg_option6_(new
CfgOption()), negative_(false),
175 Host::Host(
const std::string& identifier,
const std::string& identifier_name,
178 const std::string& hostname,
179 const std::string& dhcp4_client_classes,
180 const std::string& dhcp6_client_classes,
182 const std::string& server_host_name,
183 const std::string& boot_file_name,
185 : identifier_type_(IDENT_HWADDR),
186 identifier_value_(), ipv4_subnet_id_(ipv4_subnet_id),
187 ipv6_subnet_id_(ipv6_subnet_id),
189 hostname_(hostname), dhcp4_client_classes_(dhcp4_client_classes),
190 dhcp6_client_classes_(dhcp6_client_classes),
192 server_host_name_(server_host_name), boot_file_name_(boot_file_name),
193 host_id_(0), cfg_option4_(new
CfgOption()),
194 cfg_option6_(new
CfgOption()), negative_(false),
225 const std::vector<uint8_t>&
227 return (identifier_value_);
232 return (identifier_type_);
237 if (identifier_name ==
"hw-address") {
240 }
else if (identifier_name ==
"duid") {
243 }
else if (identifier_name ==
"circuit-id") {
246 }
else if (identifier_name ==
"client-id") {
248 }
else if (identifier_name ==
"flex-id") {
252 << identifier_name <<
"'");
272 identifier_value_.size()));
277 const size_t length) {
279 std::ostringstream s;
299 s <<
"(invalid-type)";
301 std::vector<uint8_t> vec(value, value + length);
310 return (
"hw-address");
316 return (
"circuit-id");
319 return (
"client-id");
327 return (
"(unknown)");
339 <<
" length " << len);
342 identifier_type_ = type;
343 identifier_value_.assign(identifier, identifier + len);
349 if (identifier.empty()) {
364 bool too_long =
false;
367 if (binary.empty()) {
371 size_t len = binary.size();
376 <<
" length " << len);
380 identifier_value_.swap(binary);
389 << identifier <<
"'");
395 identifier_type_ = type;
400 if (!address.
isV4()) {
405 << address <<
"' address");
407 ipv4_reservation_ = address;
420 " host reservation for " << reservation.
toText());
429 return (ipv6_reservations_.equal_range(type));
435 ipv6_reservations_.end()));
440 return (!ipv6_reservations_.empty());
446 if (std::distance(reservations.first, reservations.second) > 0) {
448 it != reservations.second; ++it) {
449 if (it->second == reservation) {
461 addClientClassInternal(dhcp4_client_classes_, class_name);
467 addClientClassInternal(dhcp6_client_classes_, class_name);
472 const std::string& class_name) {
474 if (!trimmed.empty()) {
481 if (!next_server.
isV4()) {
483 <<
"' is not a valid IPv4 address");
486 << next_server <<
"'");
489 next_server_ = next_server;
498 server_host_name_ = server_host_name;
507 boot_file_name_ = boot_file_name;
561 cclass != cclasses.
cend(); ++cclass) {
564 map->set(
"client-classes", classes);
567 map->set(
"option-data", opts->toElement());
601 resv != na_resv.second; ++resv) {
604 map->set(
"ip-addresses", resvs);
609 resv != pd_resv.second; ++resv) {
612 map->set(
"prefixes", resvs);
620 cclass != cclasses.
cend(); ++cclass) {
623 map->set(
"client-classes", classes);
627 map->set(
"option-data", opts->toElement());
638 std::ostringstream s;
644 if (ipv4_subnet_id_ != SUBNET_ID_UNUSED) {
645 s <<
" ipv4_subnet_id=" << ipv4_subnet_id_;
649 if (ipv6_subnet_id_ != SUBNET_ID_UNUSED) {
650 s <<
" ipv6_subnet_id=" << ipv6_subnet_id_;
654 s <<
" hostname=" << (hostname_.empty() ?
"(empty)" : hostname_);
657 s <<
" ipv4_reservation=" << (ipv4_reservation_.
isV4Zero() ?
"(no)" :
658 ipv4_reservation_.
toText());
661 s <<
" siaddr=" << (next_server_.
isV4Zero() ?
"(no)" :
665 s <<
" sname=" << (server_host_name_.empty() ?
"(empty)" : server_host_name_);
668 s <<
" file=" << (boot_file_name_.empty() ?
"(empty)" : boot_file_name_);
670 s <<
" key=" << (key_.
toText().empty() ?
"(empty)" : key_.
toText());
672 if (ipv6_reservations_.empty()) {
673 s <<
" ipv6_reservations=(none)";
678 resrv != ipv6_reservations_.end(); ++resrv) {
679 s <<
" ipv6_reservation"
680 << std::distance(ipv6_reservations_.begin(), resrv)
681 <<
"=" << resrv->second.toText();
687 cclass != dhcp4_client_classes_.
cend(); ++cclass) {
689 << std::distance(dhcp4_client_classes_.
cbegin(), cclass)
695 cclass != dhcp6_client_classes_.
cend(); ++cclass) {
697 << std::distance(dhcp6_client_classes_.
cbegin(), cclass)
703 s <<
" negative cached";
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown if a function is called in a prohibited way.
The IOAddress class represents an IP addresses (version agnostic)
bool isV4Zero() const
Convenience function to check if it is an IPv4 zero address.
std::string toText() const
Convert the address to a string.
bool isV6() const
Convenience function to check for an IPv6 address.
bool isV4() const
Convenience function to check for an IPv4 address.
bool isV6Multicast() const
checks whether and address is IPv6 and is multicast
bool isV4Bcast() const
Convenience function to check if it is an IPv4 broadcast address.
static const IOAddress & IPV4_ZERO_ADDRESS()
Returns an address set to all zeros.
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
static ElementPtr createList(const Position &pos=ZERO_POSITION())
Creates an empty ListElement type ElementPtr.
std::string toText() const
Return text format for keys.
Represents option data configuration for the DHCP server.
Container for storing client class names.
ClientClassContainer::const_iterator const_iterator
Type of iterators.
void insert(const ClientClass &class_name)
Insert an element.
const_iterator cbegin() const
Iterators to the first element.
const_iterator cend() const
Iterators to the past the end element.
Holds DUID (DHCPv6 Unique Identifier)
static const size_t MAX_DUID_LEN
maximum duid size As defined in RFC 8415, section 11.1
const std::string & getHostname() const
Returns reserved hostname.
void addClientClass4(const std::string &class_name)
Adds new client class for DHCPv4.
void setServerHostname(const std::string &server_host_name)
Sets new value for server hostname (sname).
const asiolink::IOAddress & getNextServer() const
Returns value of next server field (siaddr).
static size_t getIdentifierMaxLength(const IdentifierType &type)
Get maximum identifier length.
const asiolink::IOAddress & getIPv4Reservation() const
Returns reserved IPv4 address.
CfgOptionPtr getCfgOption4()
Returns pointer to the DHCPv4 option data configuration for this host.
std::string toText() const
Returns information about the host in the textual format.
void addClientClass6(const std::string &class_name)
Adds new client class for DHCPv6.
IdentifierType
Type of the host identifier.
@ IDENT_FLEX
Flexible host identifier.
IdentifierType getIdentifierType() const
Returns the identifier type.
void setIdentifier(const uint8_t *identifier, const size_t len, const IdentifierType &type)
Replaces currently used identifier with a new identifier.
const ClientClasses & getClientClasses4() const
Returns classes which DHCPv4 client is associated with.
const ClientClasses & getClientClasses6() const
Returns classes which DHCPv6 client is associated with.
const std::string & getBootFileName() const
Returns value of boot file name (file).
void setIdentifierType(const IdentifierType &type)
Set the identifier type.
const std::string & getServerHostname() const
Returns value of server hostname (sname).
IPv6ResrvRange getIPv6Reservations() const
Returns all IPv6 reservations.
bool hasIPv6Reservation() const
Checks if there is at least one IPv6 reservation for this host.
Host(const uint8_t *identifier, const size_t identifier_len, const IdentifierType &identifier_type, const SubnetID ipv4_subnet_id, const SubnetID ipv6_subnet_id, const asiolink::IOAddress &ipv4_reservation, const std::string &hostname="", const std::string &dhcp4_client_classes="", const std::string &dhcp6_client_classes="", const asiolink::IOAddress &next_server=asiolink::IOAddress::IPV4_ZERO_ADDRESS(), const std::string &server_host_name="", const std::string &boot_file_name="", const AuthKey &auth_key=AuthKey(""))
Constructor.
const std::vector< uint8_t > & getIdentifier() const
Returns the identifier in a binary form.
isc::data::ElementPtr toElement6() const
Unparses (converts to Element representation) IPv6 host.
void addReservation(const IPv6Resrv &reservation)
Adds new IPv6 reservation.
static std::string getIdentifierName(const IdentifierType &type)
Returns name of the identifier of a specified type.
void setBootFileName(const std::string &boot_file_name)
Sets new value for boot file name (file).
void setNextServer(const asiolink::IOAddress &next_server)
Sets new value for next server field (siaddr).
CfgOptionPtr getCfgOption6()
Returns pointer to the DHCPv6 option data configuration for this host.
bool hasReservation(const IPv6Resrv &reservation) const
Checks if specified IPv6 reservation exists for the host.
std::string getIdentifierAsText() const
Returns host identifier in a textual form.
isc::data::ElementPtr toElement4() const
Unparses (converts to Element representation) IPv4 host.
DuidPtr getDuid() const
Returns DUID for which the reservations are made.
void removeIPv4Reservation()
Removes the IPv4 reservation.
HWAddrPtr getHWAddress() const
Returns hardware address for which the reservations are made.
void setIPv4Reservation(const asiolink::IOAddress &address)
Sets new IPv4 reservation.
IPv6 reservation for a host.
void set(const Type &type, const asiolink::IOAddress &prefix, const uint8_t prefix_len)
Sets a new prefix and prefix length.
Type getType() const
Returns reservation type.
Type
Type of the reservation.
std::string toText() const
Returns information about the reservation in the textual format.
bool operator==(const IPv6Resrv &other) const
Equality operator.
bool operator!=(const IPv6Resrv &other) const
Inequality operator.
static const size_t MAX_SNAME_LEN
length of the SNAME field in DHCPv4 message
static const size_t MAX_FILE_LEN
length of the FILE field in DHCPv4 message
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
A wrapper interface for the ASIO library.
std::vector< uint8_t > random(size_t len)
Generate random value.
bool operator==(const Element &a, const Element &b)
bool operator!=(const Element &a, const Element &b)
boost::shared_ptr< Element > ElementPtr
IPv6ResrvCollection::const_iterator IPv6ResrvIterator
std::string ClientClass
Defines a single class name.
boost::shared_ptr< DUID > DuidPtr
std::pair< IPv6ResrvIterator, IPv6ResrvIterator > IPv6ResrvRange
boost::shared_ptr< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
const uint8_t AUTH_KEY_LEN
Maximum length of authentication keys - 128 bits.
uint32_t SubnetID
Defines unique IPv4 or IPv6 subnet identifier.
std::pair< IPv6Resrv::Type, IPv6Resrv > IPv6ResrvTuple
@ HTYPE_ETHER
Ethernet 10Mbps.
boost::shared_ptr< const CfgOption > ConstCfgOptionPtr
Const pointer.
string encodeHex(const vector< uint8_t > &binary)
Encode binary data in the base16 ('hex') format.
void decodeHex(const string &input, vector< uint8_t > &result)
Decode a text encoded in the base16 ('hex') format into the original data.
void decodeFormattedHexString(const std::string &hex_string, std::vector< uint8_t > &binary)
Converts a formatted string of hexadecimal digits into a vector.
std::vector< uint8_t > quotedStringToBinary(const std::string "ed_string)
Converts a string in quotes into vector.
string trim(const string &instring)
Trim Leading and Trailing Spaces.
Defines the logger used by the top-level component of kea-lfc.
void contextToElement(data::ElementPtr map) const
Merge unparse a user_context object.
Hardware type that represents information from DHCPv4 packet.
static const size_t MAX_HWADDR_LEN
Maximum size of a hardware address.