d2_config.h

Go to the documentation of this file.

// Copyright (C) 2013-2022 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_CONFIG_H
#define D2_CONFIG_H
 
#include <asiolink/io_service.h>
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <cc/cfg_to_element.h>
#include <cc/user_context.h>
#include <d2srv/d2_tsig_key.h>
#include <dhcpsrv/parsers/dhcp_parsers.h>
#include <exceptions/exceptions.h>
#include <process/d_cfg_mgr.h>
 
#include <boost/foreach.hpp>
 
#include <stdint.h>
#include <string>
 
namespace isc {
namespace d2 {
 
 
class D2CfgError : public isc::Exception {
public:
    D2CfgError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class D2Params {
public:
    D2Params(const isc::asiolink::IOAddress& ip_address,
                   const size_t port,
                   const size_t dns_server_timeout,
                   const dhcp_ddns::NameChangeProtocol& ncr_protocol,
                   const dhcp_ddns::NameChangeFormat& ncr_format);
 
    D2Params();
 
    virtual ~D2Params();
 
    const isc::asiolink::IOAddress& getIpAddress() const {
        return(ip_address_);
    }
 
    size_t getPort() const {
        return(port_);
    }
 
    size_t getDnsServerTimeout() const {
        return(dns_server_timeout_);
    }
 
    const dhcp_ddns::NameChangeProtocol& getNcrProtocol() const {
         return(ncr_protocol_);
    }
 
    const dhcp_ddns::NameChangeFormat& getNcrFormat() const {
        return(ncr_format_);
    }
 
    std::string getConfigSummary() const;
 
    bool operator == (const D2Params& other) const;
 
    bool operator != (const D2Params& other) const;
 
    std::string toText() const;
 
protected:
    virtual void validateContents();
 
private:
    isc::asiolink::IOAddress ip_address_;
 
    size_t port_;
 
    size_t dns_server_timeout_;
 
    dhcp_ddns::NameChangeProtocol ncr_protocol_;
 
    dhcp_ddns::NameChangeFormat ncr_format_;
};
 
std::ostream&
operator<<(std::ostream& os, const D2Params& config);
 
typedef boost::shared_ptr<D2Params> D2ParamsPtr;
 
class TSIGKeyInfo : public isc::data::UserContext, public isc::data::CfgToElement {
public:
    static const char* HMAC_MD5_STR;
    static const char* HMAC_SHA1_STR;
    static const char* HMAC_SHA256_STR;
    static const char* HMAC_SHA224_STR;
    static const char* HMAC_SHA384_STR;
    static const char* HMAC_SHA512_STR;
 
    TSIGKeyInfo(const std::string& name, const std::string& algorithm,
                const std::string& secret, uint32_t digestbits = 0);
 
    virtual ~TSIGKeyInfo();
 
    const std::string getName() const {
        return (name_);
    }
 
    const std::string getAlgorithm() const {
        return (algorithm_);
    }
 
    uint32_t getDigestbits() const {
        return (digestbits_);
    }
 
    const std::string getSecret() const {
        return (secret_);
    }
 
    const D2TsigKeyPtr& getTSIGKey() const {
        return (tsig_key_);
    }
 
    static const dns::Name& stringToAlgorithmName(const std::string&
                                                  algorithm_id);
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
    void remakeKey();
 
    std::string name_;
 
    std::string algorithm_;
 
    std::string secret_;
 
    uint32_t digestbits_;
 
    D2TsigKeyPtr tsig_key_;
};
 
typedef boost::shared_ptr<TSIGKeyInfo> TSIGKeyInfoPtr;
 
typedef std::map<std::string, TSIGKeyInfoPtr> TSIGKeyInfoMap;
 
typedef std::pair<std::string, TSIGKeyInfoPtr> TSIGKeyInfoMapPair;
 
typedef boost::shared_ptr<TSIGKeyInfoMap> TSIGKeyInfoMapPtr;
 
 
class DnsServerInfo : public isc::data::UserContext, public isc::data::CfgToElement {
public:
    static const uint32_t STANDARD_DNS_PORT = 53;
 
    DnsServerInfo(const std::string& hostname,
                  isc::asiolink::IOAddress ip_address,
                  uint32_t port = STANDARD_DNS_PORT,
                  bool enabled = true,
                  const TSIGKeyInfoPtr& tsig_key_info = TSIGKeyInfoPtr(),
                  bool inherited_key = true);
 
    virtual ~DnsServerInfo();
 
    const std::string getHostname() const {
        return (hostname_);
    }
 
    uint32_t getPort() const {
        return (port_);
    }
 
    const isc::asiolink::IOAddress& getIpAddress() const {
        return (ip_address_);
    }
 
    bool isEnabled() const {
        return (enabled_);
    }
 
    void enable() {
        enabled_ = true;
    }
 
    void disable() {
        enabled_ = false;
    }
 
    const std::string getKeyName() const;
 
    const TSIGKeyInfoPtr& getTSIGKeyInfo() {
        return (tsig_key_info_);
    }
 
    std::string toText() const;
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
    std::string hostname_;
 
    isc::asiolink::IOAddress ip_address_;
 
    uint32_t port_;
 
    bool enabled_;
 
    TSIGKeyInfoPtr tsig_key_info_;
 
    bool inherited_key_;
};
 
std::ostream&
operator<<(std::ostream& os, const DnsServerInfo& server);
 
typedef boost::shared_ptr<DnsServerInfo> DnsServerInfoPtr;
 
typedef std::vector<DnsServerInfoPtr> DnsServerInfoStorage;
 
typedef boost::shared_ptr<DnsServerInfoStorage> DnsServerInfoStoragePtr;
 
 
class DdnsDomain : public isc::data::UserContext, public isc::data::CfgToElement {
public:
    DdnsDomain(const std::string& name, DnsServerInfoStoragePtr servers,
               const std::string& key_name = "");
 
    virtual ~DdnsDomain();
 
    const std::string getName() const {
        return (name_);
    }
 
    const std::string getKeyName() const {
        return (key_name_);
    }
 
    const DnsServerInfoStoragePtr& getServers() {
        return (servers_);
    }
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
    std::string name_;
 
    DnsServerInfoStoragePtr servers_;
 
    std::string key_name_;
};
 
typedef boost::shared_ptr<DdnsDomain> DdnsDomainPtr;
 
typedef std::map<std::string, DdnsDomainPtr> DdnsDomainMap;
 
typedef std::pair<std::string, DdnsDomainPtr> DdnsDomainMapPair;
 
typedef boost::shared_ptr<DdnsDomainMap> DdnsDomainMapPtr;
 
class DdnsDomainListMgr : public isc::data::CfgToElement {
public:
    static const char* wildcard_domain_name_;
 
    DdnsDomainListMgr(const std::string& name);
 
    virtual ~DdnsDomainListMgr ();
 
    virtual bool matchDomain(const std::string& fqdn, DdnsDomainPtr& domain);
 
    const std::string getName() const {
        return (name_);
    }
 
    uint32_t size() const {
        return (domains_->size());
    }
 
    const DdnsDomainPtr& getWildcardDomain() {
        return (wildcard_domain_);
    }
 
    const DdnsDomainMapPtr &getDomains() {
        return (domains_);
    }
 
    void setDomains(DdnsDomainMapPtr domains);
 
    virtual isc::data::ElementPtr toElement() const;
 
private:
    std::string name_;
 
    DdnsDomainMapPtr domains_;
 
    DdnsDomainPtr wildcard_domain_;
};
 
typedef boost::shared_ptr<DdnsDomainListMgr> DdnsDomainListMgrPtr;
 
class DScalarContext : public process::ConfigBase {
public:
 
    DScalarContext() {
    };
 
    virtual ~DScalarContext() {
    }
 
    virtual process::ConfigPtr clone() {
        return (process::ConfigPtr(new DScalarContext(*this)));
    }
 
    virtual isc::data::ElementPtr toElement() const {
        isc_throw(isc::NotImplemented, "DScalarContext::ElementPtr");
    }
 
protected:
    DScalarContext(const DScalarContext& rhs) : ConfigBase(rhs) {
    }
 
private:
    DScalarContext& operator=(const DScalarContext& rhs);
};
 
typedef boost::shared_ptr<DScalarContext> DScalarContextPtr;
 
class TSIGKeyInfoParser : public data::SimpleParser {
public:
    TSIGKeyInfoPtr parse(data::ConstElementPtr key_config);
 
};
 
class TSIGKeyInfoListParser : public data::SimpleParser {
public:
    TSIGKeyInfoMapPtr parse(data::ConstElementPtr key_list_config);
};
 
class DnsServerInfoParser : public data::SimpleParser {
public:
    DnsServerInfoPtr parse(data::ConstElementPtr server_config,
                           data::ConstElementPtr domain_config,
                           const TSIGKeyInfoMapPtr keys);
};
 
class DnsServerInfoListParser : public data::SimpleParser {
public:
    DnsServerInfoStoragePtr parse(data::ConstElementPtr server_list_config,
                                  data::ConstElementPtr domain_config,
                                  const TSIGKeyInfoMapPtr keys);
};
 
class DdnsDomainParser : public data::SimpleParser {
public:
    DdnsDomainPtr parse(data::ConstElementPtr domain_config,
                        const TSIGKeyInfoMapPtr keys);
};
 
class DdnsDomainListParser : public data::SimpleParser {
public:
    DdnsDomainMapPtr parse(data::ConstElementPtr domain_list_config,
                           const TSIGKeyInfoMapPtr keys);
};
 
class DdnsDomainListMgrParser : public data::SimpleParser {
public:
    DdnsDomainListMgrPtr parse(data::ConstElementPtr mgr_config,
                               const std::string& mgr_name,
                               const TSIGKeyInfoMapPtr keys);
};
 
} // end of isc::d2 namespace
} // end of isc namespace
 
#endif // D2_CONFIG_H