d2_client_cfg.h

Go to the documentation of this file.

// Copyright (C) 2013-2018 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 D2_CLIENT_CFG_H
#define D2_CLIENT_CFG_H
 
 
#include <asiolink/io_address.h>
#include <cc/cfg_to_element.h>
#include <cc/user_context.h>
#include <dhcp_ddns/ncr_io.h>
#include <exceptions/exceptions.h>
#include <util/strutil.h>
 
#include <boost/shared_ptr.hpp>
 
#include <stdint.h>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {
 
 
class D2ClientError : public isc::Exception {
public:
 
    D2ClientError(const char* file, size_t line, const char* what)
        : isc::Exception(file, line, what) {}
};
 
 
class D2ClientConfig : public data::UserContext, public isc::data::CfgToElement {
public:
    static const char* DFT_SERVER_IP;
    static const size_t DFT_SERVER_PORT;
    static const char* DFT_V4_SENDER_IP;
    static const char* DFT_V6_SENDER_IP;
    static const size_t DFT_SENDER_PORT;
    static const size_t DFT_MAX_QUEUE_SIZE;
    static const char* DFT_NCR_PROTOCOL;
    static const char* DFT_NCR_FORMAT;
    static const bool DFT_OVERRIDE_NO_UPDATE;
    static const bool DFT_OVERRIDE_CLIENT_UPDATE;
    static const char* DFT_REPLACE_CLIENT_NAME_MODE;
    static const char* DFT_GENERATED_PREFIX;
    static const char* DFT_HOSTNAME_CHAR_SET;
    static const char* DFT_HOSTNAME_CHAR_REPLACEMENT;
 
    enum ReplaceClientNameMode  {
        RCM_NEVER,
        RCM_ALWAYS,
        RCM_WHEN_PRESENT,
        RCM_WHEN_NOT_PRESENT
    };
 
    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,
                   const bool override_no_update,
                   const bool override_client_update,
                   const ReplaceClientNameMode replace_client_name_mode,
                   const std::string& generated_prefix,
                   const std::string& qualifying_suffix,
                   const std::string& hostname_char_set,
                   const std::string& hostname_char_replacement);
 
 
    D2ClientConfig();
 
    virtual ~D2ClientConfig();
 
    bool getEnableUpdates() const {
        return(enable_updates_);
    }
 
    const isc::asiolink::IOAddress& getServerIp() const {
        return(server_ip_);
    }
 
    size_t getServerPort() const {
        return(server_port_);
    }
 
    const isc::asiolink::IOAddress& getSenderIp() const {
        return(sender_ip_);
    }
 
    size_t getSenderPort() const {
        return(sender_port_);
    }
 
    size_t getMaxQueueSize() const {
        return(max_queue_size_);
    }
 
    const dhcp_ddns::NameChangeProtocol& getNcrProtocol() const {
         return(ncr_protocol_);
    }
 
    const dhcp_ddns::NameChangeFormat& getNcrFormat() const {
        return(ncr_format_);
    }
 
    bool getOverrideNoUpdate() const {
        return(override_no_update_);
    }
 
    bool getOverrideClientUpdate() const {
        return(override_client_update_);
    }
 
    ReplaceClientNameMode getReplaceClientNameMode() const {
        return(replace_client_name_mode_);
    }
 
    const std::string& getGeneratedPrefix() const {
        return(generated_prefix_);
    }
 
    const std::string& getQualifyingSuffix() const {
        return(qualifying_suffix_);
    }
 
    const std::string& getHostnameCharSet() const {
        return(hostname_char_set_);
    }
 
    const std::string& getHostnameCharReplacement() const {
        return(hostname_char_replacement_);
    }
 
    util::str::StringSanitizerPtr getHostnameSanitizer() const {
        return(hostname_sanitizer_);
    }
 
    bool operator == (const D2ClientConfig& other) const;
 
    bool operator != (const D2ClientConfig& other) const;
 
    std::string toText() const;
 
    void enableUpdates(bool enable);
 
    static ReplaceClientNameMode stringToReplaceClientNameMode(const std::string& mode_str);
 
    static std::string replaceClientNameModeToString(const ReplaceClientNameMode& mode);
 
    virtual isc::data::ElementPtr toElement() const;
 
protected:
    virtual void validateContents();
 
private:
    bool enable_updates_;
 
    isc::asiolink::IOAddress server_ip_;
 
    size_t server_port_;
 
    isc::asiolink::IOAddress sender_ip_;
 
    size_t sender_port_;
 
    size_t max_queue_size_;
 
    dhcp_ddns::NameChangeProtocol ncr_protocol_;
 
    dhcp_ddns::NameChangeFormat ncr_format_;
 
    bool override_no_update_;
 
    bool override_client_update_;
 
    ReplaceClientNameMode replace_client_name_mode_;
 
    std::string generated_prefix_;
 
    std::string qualifying_suffix_;
 
    std::string hostname_char_set_;
 
    std::string hostname_char_replacement_;
 
    util::str::StringSanitizerPtr hostname_sanitizer_;
};
 
std::ostream&
operator<<(std::ostream& os, const D2ClientConfig& config);
 
typedef boost::shared_ptr<D2ClientConfig> D2ClientConfigPtr;
 
} // namespace isc
} // namespace dhcp
 
#endif