host.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef HOST_H
#define HOST_H
 
#include <asiolink/io_address.h>
#include <cc/data.h>
#include <cc/user_context.h>
#include <dhcp/classify.h>
#include <dhcp/duid.h>
#include <dhcp/hwaddr.h>
#include <dhcp/option6_pdexclude.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/subnet_id.h>
#include <boost/shared_ptr.hpp>
#include <boost/algorithm/string.hpp>
#include <list>
#include <map>
#include <string>
#include <utility>
 
namespace isc {
namespace dhcp {
 
const size_t ADDRESS6_TEXT_MAX_LEN = 39;
 
const size_t CLIENT_CLASSES_MAX_LEN = 255;
 
const size_t HOSTNAME_MAX_LEN = 255;
 
const size_t OPTION_VALUE_MAX_LEN = 4096;
 
const size_t OPTION_FORMATTED_VALUE_MAX_LEN = 8192;
 
const size_t OPTION_SPACE_MAX_LEN = 128;
 
const size_t USER_CONTEXT_MAX_LEN = 8192;
 
const size_t SERVER_HOSTNAME_MAX_LEN = 64;
 
const size_t BOOT_FILE_NAME_MAX_LEN = 128;
 
const uint8_t AUTH_KEY_LEN = 16;
 
const size_t TEXT_AUTH_KEY_LEN = AUTH_KEY_LEN * 2;
 
typedef uint64_t HostID;
 
class AuthKey {
public:
    AuthKey(const std::vector<uint8_t>& key);
 
    AuthKey(const std::string& key);
 
    AuthKey();
 
    // @brief Get random string.
    static std::vector<uint8_t> getRandomKeyString();
 
    //  If the size is greater than 16 bytes, we resize to 16 bytes.
    void setAuthKey(const std::vector<uint8_t>& key);
 
    void setAuthKey(const std::string& key);
 
    const std::vector<uint8_t>& getAuthKey() const {
        return authKey_;
    }
 
    std::string toText() const;
 
    bool operator==(const AuthKey& other) const;
 
    bool operator!=(const AuthKey& other) const;
 
private:
    std::vector<uint8_t> authKey_;
};
 
class IPv6Resrv {
public:
 
    enum Type {
        TYPE_NA,
        TYPE_PD
    };
 
    IPv6Resrv(const Type& type,
              const asiolink::IOAddress& prefix,
              const uint8_t prefix_len = 128);
 
    const asiolink::IOAddress& getPrefix() const {
        return (prefix_);
    }
 
    uint8_t getPrefixLen() const {
        return (prefix_len_);
    }
 
    Type getType() const {
        return (type_);
    }
 
    Option6PDExcludePtr getPDExclude() const {
        return (pd_exclude_option_);
    }
 
    void set(const Type& type, const asiolink::IOAddress& prefix,
             const uint8_t prefix_len);
 
    void setPDExclude(const asiolink::IOAddress& excluded_prefix,
                      const uint8_t excluded_prefix_len);
 
    std::string toText(bool display_pd_exclude_option = true) const;
 
    std::string PDExcludetoText() const;
 
    bool operator==(const IPv6Resrv& other) const;
 
    bool operator!=(const IPv6Resrv& other) const;
 
private:
 
    Type type_;                             
    asiolink::IOAddress prefix_;            
    uint8_t prefix_len_;                    
    Option6PDExcludePtr pd_exclude_option_; 
};
 
typedef std::multimap<IPv6Resrv::Type, IPv6Resrv> IPv6ResrvCollection;
typedef IPv6ResrvCollection::const_iterator IPv6ResrvIterator;
typedef std::pair<IPv6Resrv::Type, IPv6Resrv> IPv6ResrvTuple;
typedef std::pair<IPv6ResrvIterator, IPv6ResrvIterator> IPv6ResrvRange;
 
class Host : public data::UserContext {
public:
 
    enum IdentifierType {
        IDENT_HWADDR,
        IDENT_DUID,
        IDENT_CIRCUIT_ID,
        IDENT_CLIENT_ID,
        IDENT_FLEX, 
    };
 
    static const IdentifierType LAST_IDENTIFIER_TYPE = IDENT_FLEX;
 
    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(""));
 
    Host(const std::string& identifier, const std::string& identifier_name,
         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(""));
 
    static size_t getIdentifierMaxLength(const IdentifierType& type);
 
    void setIdentifier(const uint8_t* identifier, const size_t len,
                       const IdentifierType& type);
 
    void setIdentifier(const std::string& identifier, const std::string& name);
 
    HWAddrPtr getHWAddress() const;
 
    DuidPtr getDuid() const;
 
    const std::vector<uint8_t>& getIdentifier() const;
 
    IdentifierType getIdentifierType() const;
 
    static IdentifierType getIdentifierType(const std::string& identifier_name);
 
    std::string getIdentifierAsText() const;
 
    static std::string getIdentifierName(const IdentifierType& type);
 
    static std::string getIdentifierAsText(const IdentifierType& type,
                                           const uint8_t* value,
                                           const size_t length);
 
    void setIPv4SubnetID(const SubnetID ipv4_subnet_id) {
        ipv4_subnet_id_ = ipv4_subnet_id;
    }
 
    void setIPv6SubnetID(const SubnetID ipv6_subnet_id) {
        ipv6_subnet_id_ = ipv6_subnet_id;
    }
 
    SubnetID getIPv4SubnetID() const {
        return (ipv4_subnet_id_);
    }
 
    SubnetID getIPv6SubnetID() const {
        return (ipv6_subnet_id_);
    }
 
    void setIPv4Reservation(const asiolink::IOAddress& address);
 
    void removeIPv4Reservation();
 
    const asiolink::IOAddress& getIPv4Reservation() const {
        return (ipv4_reservation_);
    }
 
    void addReservation(const IPv6Resrv& reservation);
 
    IPv6ResrvRange getIPv6Reservations(const IPv6Resrv::Type& type) const;
 
    IPv6ResrvRange getIPv6Reservations() const;
 
    bool hasIPv6Reservation() const;
 
    bool hasReservation(const IPv6Resrv& reservation) const;
 
    void setHostname(const std::string& hostname) {
        hostname_ = hostname;
    }
 
    const std::string& getHostname() const {
        return (hostname_);
    }
 
    std::string getLowerHostname() const {
        return (boost::algorithm::to_lower_copy(hostname_));
    }
 
    void addClientClass4(const std::string& class_name);
 
    const ClientClasses& getClientClasses4() const {
        return (dhcp4_client_classes_);
    }
 
    void addClientClass6(const std::string& class_name);
 
    const ClientClasses& getClientClasses6() const {
        return (dhcp6_client_classes_);
    }
 
    void setNextServer(const asiolink::IOAddress& next_server);
 
    const asiolink::IOAddress& getNextServer() const {
        return (next_server_);
    }
 
    void setServerHostname(const std::string& server_host_name);
 
    const std::string& getServerHostname() const {
        return (server_host_name_);
    }
 
    void setBootFileName(const std::string& boot_file_name);
 
    const std::string& getBootFileName() const {
        return (boot_file_name_);
    }
 
    CfgOptionPtr getCfgOption4() {
        return (cfg_option4_);
    }
 
    ConstCfgOptionPtr getCfgOption4() const {
        return (cfg_option4_);
    }
 
    CfgOptionPtr getCfgOption6() {
        return (cfg_option6_);
    }
 
    ConstCfgOptionPtr getCfgOption6() const {
        return (cfg_option6_);
    }
 
    void encapsulateOptions() const;
 
    std::string toText() const;
 
    void setHostId(HostID id) {
        host_id_ = id;
    }
 
    HostID getHostId() const {
        return (host_id_);
    }
 
    void setNegative(bool negative) {
        negative_ = negative;
    }
 
    bool getNegative() const {
        return (negative_);
    }
 
    isc::data::ElementPtr toElement4() const;
 
    isc::data::ElementPtr toElement6() const;
 
    void setKey(const AuthKey& key) {
        key_ = key;
    }
 
    AuthKey getKey() const {
        return(key_);
    }
 
protected:
 
    void setIdentifierType(const IdentifierType& type);
 
private:
 
    void addClientClassInternal(ClientClasses& classes,
                                const std::string& class_name);
 
    IdentifierType identifier_type_;
    std::vector<uint8_t> identifier_value_;
    SubnetID ipv4_subnet_id_;
    SubnetID ipv6_subnet_id_;
    asiolink::IOAddress ipv4_reservation_;
    IPv6ResrvCollection ipv6_reservations_;
    std::string hostname_;
    ClientClasses dhcp4_client_classes_;
    ClientClasses dhcp6_client_classes_;
    asiolink::IOAddress next_server_;
    std::string server_host_name_;
    std::string boot_file_name_;
 
    uint64_t host_id_;
 
    CfgOptionPtr cfg_option4_;
    CfgOptionPtr cfg_option6_;
 
    bool negative_;
 
    AuthKey key_;
};
 
typedef boost::shared_ptr<Host> HostPtr;
 
typedef boost::shared_ptr<const Host> ConstHostPtr;
 
typedef std::vector<ConstHostPtr> ConstHostCollection;
 
typedef std::vector<HostPtr> HostCollection;
 
}
}
 
#endif // HOST_H