19#include <boost/foreach.hpp> 
   47    if (authKey_.empty()) {
 
 
   68        std::vector<uint8_t> bin;
 
   71    } 
catch (
const std::exception& ex) {
 
 
   78    return (authKey_ == other.authKey_);
 
 
   83    return (authKey_ != other.authKey_);
 
 
   88                     const uint8_t prefix_len)
 
   90      pd_exclude_option_() {
 
   92    set(type, prefix, prefix_len);
 
 
   97               const uint8_t prefix_len) {
 
  100                  << 
"' for new IPv6 reservation");
 
  102    } 
else if (prefix_len > 128) {
 
  104                  << 
static_cast<int>(prefix_len)
 
  105                  << 
"' for new IPv6 reservation");
 
  107    } 
else if ((type == 
TYPE_NA) && (prefix_len != 128)) {
 
  109                  << 
static_cast<int>(prefix_len)
 
  110                  << 
"' for reserved IPv6 address, expected 128");
 
  115    prefix_len_ = prefix_len;
 
  116    pd_exclude_option_.reset();
 
 
  121                        const uint8_t excluded_prefix_len) {
 
  122    if (excluded_prefix_len == 0) {
 
  123        pd_exclude_option_.reset();
 
  127                                                      excluded_prefix_len));
 
 
  133    std::ostringstream s;
 
  137        s << 
"/" << 
static_cast<int>(prefix_len_);
 
  139        if (display_pd_exclude_option && pd_exclude_option_) {
 
  140            s << 
" (excluded_prefix=" 
  141              << pd_exclude_option_->getExcludedPrefix(prefix_,
 
  142                                                       prefix_len_).toText()
 
  144              << 
static_cast<int>(pd_exclude_option_->getExcludedPrefixLength())
 
 
  153    if (pd_exclude_option_) {
 
  154        std::ostringstream s;
 
  155        s << pd_exclude_option_->getExcludedPrefix(prefix_,
 
  156                                                   prefix_len_).toText()
 
  158          << 
static_cast<int>(pd_exclude_option_->getExcludedPrefixLength());
 
 
  167    return (type_ == other.type_ &&
 
  168            prefix_ == other.prefix_ &&
 
  169            prefix_len_ == other.prefix_len_);
 
 
  174    return (!
operator==(other));
 
 
  177Host::Host(
const uint8_t* identifier, 
const size_t identifier_len,
 
  181           const std::string& hostname,
 
  182           const std::string& dhcp4_client_classes,
 
  183           const std::string& dhcp6_client_classes,
 
  185           const std::string& server_host_name,
 
  186           const std::string& boot_file_name,
 
  189    : identifier_type_(identifier_type),
 
  190      identifier_value_(), ipv4_subnet_id_(ipv4_subnet_id),
 
  191      ipv6_subnet_id_(ipv6_subnet_id),
 
  193      hostname_(hostname), dhcp4_client_classes_(dhcp4_client_classes),
 
  194      dhcp6_client_classes_(dhcp6_client_classes),
 
  196      server_host_name_(server_host_name), boot_file_name_(boot_file_name),
 
  197      host_id_(0), cfg_option4_(new 
CfgOption()),
 
  198      cfg_option6_(new 
CfgOption()), negative_(false),
 
 
  215Host::Host(
const std::string& identifier, 
const std::string& identifier_name,
 
  218           const std::string& hostname,
 
  219           const std::string& dhcp4_client_classes,
 
  220           const std::string& dhcp6_client_classes,
 
  222           const std::string& server_host_name,
 
  223           const std::string& boot_file_name,
 
  226      identifier_value_(), ipv4_subnet_id_(ipv4_subnet_id),
 
  227      ipv6_subnet_id_(ipv6_subnet_id),
 
  229      hostname_(hostname), dhcp4_client_classes_(dhcp4_client_classes),
 
  230      dhcp6_client_classes_(dhcp6_client_classes),
 
  232      server_host_name_(server_host_name), boot_file_name_(boot_file_name),
 
  233      host_id_(0), cfg_option4_(new 
CfgOption()),
 
  234      cfg_option6_(new 
CfgOption()), negative_(false),
 
 
  267const std::vector<uint8_t>&
 
  269    return (identifier_value_);
 
 
  274    return (identifier_type_);
 
 
  279    if (identifier_name == 
"hw-address") {
 
  282    } 
else if (identifier_name == 
"duid") {
 
  285    } 
else if (identifier_name == 
"circuit-id") {
 
  288    } 
else if (identifier_name == 
"client-id") {
 
  290    } 
else if (identifier_name == 
"flex-id") {
 
  294                  << identifier_name << 
"'");
 
 
  314                                identifier_value_.size()));
 
 
  319                          const size_t length) {
 
  321    std::ostringstream s;
 
  341        s << 
"(invalid-type)";
 
  343    std::vector<uint8_t> vec(value, value + length);
 
 
  352        return (
"hw-address");
 
  358        return (
"circuit-id");
 
  361        return (
"client-id");
 
  369    return (
"(unknown)");
 
 
  381                  << 
" length " << len);
 
  384    identifier_type_ = type;
 
  385    identifier_value_.assign(identifier, identifier + len);
 
 
  391    if (identifier.empty()) {
 
  406    bool too_long = 
false;
 
  409        if (binary.empty()) {
 
  413        size_t len = binary.size();
 
  418                      << 
" length " << len);
 
  422        identifier_value_.swap(binary);
 
  431                  << identifier << 
"'");
 
 
  437    identifier_type_ = type;
 
 
  442    if (!address.
isV4()) {
 
  447                  << address << 
"' address");
 
  449    ipv4_reservation_ = address;
 
 
  462                  " host reservation for " << reservation.
toText());
 
 
  471    return (ipv6_reservations_.equal_range(type));
 
 
  477                           ipv6_reservations_.end()));
 
 
  482    return (!ipv6_reservations_.empty());
 
 
  488    if (std::distance(reservations.first, reservations.second) > 0) {
 
  489        BOOST_FOREACH(
auto const& it, reservations) {
 
  490            if (it.second == reservation) {
 
 
  502    addClientClassInternal(dhcp4_client_classes_, class_name);
 
 
  508    addClientClassInternal(dhcp6_client_classes_, class_name);
 
 
  513                             const std::string& class_name) {
 
  515    if (!trimmed.empty()) {
 
  522    if (!next_server.
isV4()) {
 
  524                  << 
"' is not a valid IPv4 address");
 
  527                  << next_server << 
"'");
 
  530    next_server_ = next_server;
 
 
  539    server_host_name_ = server_host_name;
 
 
  548    boot_file_name_ = boot_file_name;
 
 
  601    for (
auto const& cclass : cclasses) {
 
  604    map->set(
"client-classes", classes);
 
  607    map->set(
"option-data", opts->toElement());
 
 
  640    BOOST_FOREACH(
auto const& resv, na_resv) {
 
  643    map->set(
"ip-addresses", resvs);
 
  647    bool has_pd_exclude_option(
false);
 
  648    BOOST_FOREACH(
auto const& resv, pd_resv) {
 
  649        if (resv.second.getPDExclude()) {
 
  650            has_pd_exclude_option = 
true;
 
  654    map->set(
"prefixes", resvs);
 
  656    if (has_pd_exclude_option) {
 
  658        BOOST_FOREACH(
auto const& resv, pd_resv) {
 
  661        map->set(
"excluded-prefixes", options);
 
  669    for (
auto const& cclass : cclasses) {
 
  672    map->set(
"client-classes", classes);
 
  676    map->set(
"option-data", opts->toElement());
 
 
  687    if (!cfg_option4_->isEncapsulated()) {
 
  688        cfg_option4_->encapsulate();
 
  690    if (!cfg_option6_->isEncapsulated()) {
 
  691        cfg_option6_->encapsulate();
 
 
  697    std::ostringstream s;
 
  703    if (ipv4_subnet_id_ != SUBNET_ID_UNUSED) {
 
  704        s << 
" ipv4_subnet_id=" << ipv4_subnet_id_;
 
  708    if (ipv6_subnet_id_ != SUBNET_ID_UNUSED) {
 
  709        s << 
" ipv6_subnet_id=" << ipv6_subnet_id_;
 
  713    s << 
" hostname=" << (hostname_.empty() ? 
"(empty)" : hostname_);
 
  716    s << 
" ipv4_reservation=" << (ipv4_reservation_.isV4Zero() ? 
"(no)" :
 
  717                                  ipv4_reservation_.toText());
 
  720    s << 
" siaddr=" << (next_server_.isV4Zero() ? 
"(no)" :
 
  721                             next_server_.toText());
 
  724    s << 
" sname=" << (server_host_name_.empty() ? 
"(empty)" : server_host_name_);
 
  727    s << 
" file=" << (boot_file_name_.empty() ? 
"(empty)" : boot_file_name_);
 
  729    s << 
" key=" << (key_.toText().empty() ? 
"(empty)" : key_.toText());
 
  733    if (ipv6_reservations_.empty()) {
 
  734        s << 
" ipv6_reservations=(none)";
 
  739        for (
auto const& resrv : ipv6_reservations_) {
 
  740            s << 
" ipv6_reservation" 
  742              << 
"=" << resrv.second.toText();
 
  748    for (
auto const& cclass : dhcp4_client_classes_) {
 
  756    for (
auto const& cclass : dhcp6_client_classes_) {
 
  764        s << 
" negative cached";
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
A generic exception that is thrown if a function is called in a prohibited way.
The IOAddress class represents an IP addresses (version agnostic)
static const IOAddress & IPV4_ZERO_ADDRESS()
Returns an address set to all zeros.
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 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.
bool operator!=(const AuthKey &other) const
Inequality operator.
static std::vector< uint8_t > getRandomKeyString()
Random string is generated by default will be used for the keys to be used for signing Reconfigure Me...
std::string toText() const
Return text format for keys.
AuthKey(const std::vector< uint8_t > &key)
Constructor.
void setAuthKey(const std::vector< uint8_t > &key)
Set auth key value from binary.
bool operator==(const AuthKey &other) const
Equality operator.
Represents option data configuration for the DHCP server.
Container for storing client class names.
void insert(const ClientClass &class_name)
Insert an element.
static constexpr size_t MAX_CLIENT_ID_LEN
Maximum size of a client ID.
Holds DUID (DHCPv6 Unique Identifier)
static constexpr size_t MAX_DUID_LEN
maximum duid size
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).
static size_t getIdentifierMaxLength(const IdentifierType &type)
Get maximum identifier length.
void encapsulateOptions() const
Encapsulates host-specific options with their suboptions.
const ClientClasses & getClientClasses6() const
Returns classes which DHCPv6 client is associated with.
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 asiolink::IOAddress & getIPv4Reservation() const
Returns reserved IPv4 address.
void setIdentifierType(const IdentifierType &type)
Set the identifier type.
const std::string & getHostname() const
Returns reserved hostname.
IPv6ResrvRange getIPv6Reservations() const
Returns all IPv6 reservations.
const std::string & getBootFileName() const
Returns value of boot file name (file).
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.
const ClientClasses & getClientClasses4() const
Returns classes which DHCPv4 client is associated with.
static std::string getIdentifierName(const IdentifierType &type)
Returns name of the identifier of a specified type.
const std::string & getServerHostname() const
Returns value of server hostname (sname).
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.
const asiolink::IOAddress & getNextServer() const
Returns value of next server field (siaddr).
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.
std::string PDExcludetoText() const
Returns information about the Prefix Exclude option of the reservation the textual format.
Type getType() const
Returns reservation type.
Type
Type of the reservation.
void setPDExclude(const asiolink::IOAddress &excluded_prefix, const uint8_t excluded_prefix_len)
Sets the Prefix Exclude option.
IPv6Resrv(const Type &type, const asiolink::IOAddress &prefix, const uint8_t prefix_len=128)
Constructor.
bool operator==(const IPv6Resrv &other) const
Equality operator.
std::string toText(bool display_pd_exclude_option=true) const
Returns information about the reservation in the textual format.
bool operator!=(const IPv6Resrv &other) const
Inequality operator.
DHCPv6 option class representing Prefix Exclude Option (RFC 6603).
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.
boost::shared_ptr< Element > ElementPtr
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.
void decodeHex(const string &encoded_str, vector< uint8_t > &output)
Decode a base16 encoded string into binary data.
string encodeHex(const vector< uint8_t > &binary)
Encode binary data in the base16 format.
void decodeFormattedHexString(const string &hex_string, vector< uint8_t > &binary)
Converts a formatted string of hexadecimal digits into a vector.
vector< uint8_t > quotedStringToBinary(const string "ed_string)
Converts a string in quotes into vector.
string trim(const string &input)
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.