42    if (mode_str == 
"never") {
 
   46    if (mode_str == 
"always") {
 
   50    if (mode_str == 
"when-present") {
 
   54    if (mode_str == 
"when-not-present") {
 
   59              "Invalid ReplaceClientNameMode: " << mode_str);
 
 
   70        return (
"when-present");
 
   72        return (
"when-not-present");
 
   77    std::ostringstream stream;
 
   78    stream  << 
"unknown(" << mode << 
")";
 
   79    return (stream.str());
 
 
   84                               const size_t server_port,
 
   86                               const size_t sender_port,
 
   87                               const size_t max_queue_size,
 
   89                                     NameChangeProtocol& ncr_protocol,
 
   91                                     NameChangeFormat& ncr_format)
 
   92    : enable_updates_(enable_updates),
 
   93      server_ip_(server_ip),
 
   94      server_port_(server_port),
 
   95      sender_ip_(sender_ip),
 
   96      sender_port_(sender_port),
 
   97      max_queue_size_(max_queue_size),
 
   98      ncr_protocol_(ncr_protocol),
 
   99      ncr_format_(ncr_format) {
 
 
  104    : enable_updates_(false),
 
 
  119    enable_updates_ = enable;
 
 
  127                    << 
" is not yet supported");
 
  133                  << 
" is not yet supported");
 
  136    if (sender_ip_.getFamily() != server_ip_.getFamily()) {
 
  138                  << 
"server-ip: " << server_ip_.toText()
 
  139                  << 
" is: " << (server_ip_.isV4() ? 
"IPv4" : 
"IPv6")
 
  140                  << 
" while sender-ip: "  << sender_ip_.toText()
 
  141                  << 
" is: " << (sender_ip_.isV4() ? 
"IPv4" : 
"IPv6"));
 
  144    if (server_ip_ == sender_ip_ && server_port_ == sender_port_) {
 
  146                  " share the exact same IP address/port: " 
  147                  << server_ip_.toText() << 
"/" << server_port_);
 
 
  156    return ((enable_updates_ == other.enable_updates_) &&
 
  157            (server_ip_ == other.server_ip_) &&
 
  158            (server_port_ == other.server_port_) &&
 
  159            (sender_ip_ == other.sender_ip_) &&
 
  160            (sender_port_ == other.sender_port_) &&
 
  161            (max_queue_size_ == other.max_queue_size_) &&
 
  162            (ncr_protocol_ == other.ncr_protocol_) &&
 
  163            (ncr_format_ == other.ncr_format_));
 
 
  168    return (!(*
this == other));
 
 
  173    std::ostringstream stream;
 
  175    stream << 
"enable_updates: " << (enable_updates_ ? 
"yes" : 
"no");
 
  176    if (enable_updates_) {
 
  177        stream << 
", server-ip: " << server_ip_.toText()
 
  178               << 
", server-port: " << server_port_
 
  179               << 
", sender-ip: " << sender_ip_.toText()
 
  180               << 
", sender-port: " << sender_port_
 
  181               << 
", max-queue-size: " << max_queue_size_
 
  182               << 
", ncr-protocol: " << ncrProtocolToString(ncr_protocol_)
 
  183               << 
", ncr-format: " << ncrFormatToString(ncr_format_);
 
  187    return (stream.str());
 
 
  200    result->set(
"server-port", 
Element::create(
static_cast<long long>(server_port_)));
 
  204    result->set(
"sender-port", 
Element::create(
static_cast<long long>(sender_port_)));
 
  206    result->set(
"max-queue-size", 
Element::create(
static_cast<long long>(max_queue_size_)));
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
The IOAddress class represents an IP addresses (version agnostic)
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
Acts as a storage vault for D2 client configuration.
std::string toText() const
Generates a string representation of the class contents.
static const bool DFT_OVERRIDE_CLIENT_UPDATE
static const char * DFT_NCR_FORMAT
static ReplaceClientNameMode stringToReplaceClientNameMode(const std::string &mode_str)
Converts labels to ReplaceClientNameMode enum values.
ReplaceClientNameMode
Defines the client name replacement modes.
static std::string replaceClientNameModeToString(const ReplaceClientNameMode &mode)
Converts NameChangeFormat enums to text labels.
static const char * DFT_V4_SENDER_IP
static const size_t DFT_SENDER_PORT
virtual void validateContents()
Validates member values.
bool operator==(const D2ClientConfig &other) const
Compares two D2ClientConfigs for equality.
static const char * DFT_HOSTNAME_CHAR_REPLACEMENT
D2ClientConfig(const bool enable_updates, const isc::asiolink::IOAddress &server_ip, const size_t server_port, const isc::asiolink::IOAddress &sender_ip, const size_t sender_port, const size_t max_queue_size, const dhcp_ddns::NameChangeProtocol &ncr_protocol, const dhcp_ddns::NameChangeFormat &ncr_format)
Constructor.
static const char * DFT_NCR_PROTOCOL
void enableUpdates(bool enable)
Sets enable-updates flag to the given value.
static const bool DFT_OVERRIDE_NO_UPDATE
virtual ~D2ClientConfig()
Destructor.
static const char * DFT_SERVER_IP
Default configuration constants.
static const char * DFT_V6_SENDER_IP
bool operator!=(const D2ClientConfig &other) const
Compares two D2ClientConfigs for inequality.
virtual isc::data::ElementPtr toElement() const
Unparse a configuration object.
static const size_t DFT_SERVER_PORT
static const char * DFT_GENERATED_PREFIX
static const char * DFT_REPLACE_CLIENT_NAME_MODE
static const char * DFT_HOSTNAME_CHAR_SET
static const size_t DFT_MAX_QUEUE_SIZE
D2ClientConfig()
Default constructor The default constructor creates an instance that has updates disabled.
An exception that is thrown if an error occurs while configuring the D2 DHCP DDNS client.
Defines the D2ClientConfig class.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
A wrapper interface for the ASIO library.
std::ostream & operator<<(std::ostream &os, const IOAddress &address)
Insert the IOAddress as a string into stream.
boost::shared_ptr< Element > ElementPtr
std::string ncrProtocolToString(NameChangeProtocol protocol)
Function which converts NameChangeProtocol enums to text labels.
std::string ncrFormatToString(NameChangeFormat format)
Function which converts NameChangeFormat enums to text labels.
Defines the logger used by the top-level component of kea-lfc.
This file provides UDP socket based implementation for sending and receiving NameChangeRequests.
void contextToElement(data::ElementPtr map) const
Merge unparse a user_context object.