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