d2_config.h

Go to the documentation of this file.

// Copyright (C) 2013-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 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 <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, std::string secret_file = "",
                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 std::string getSecretFile() const {
        return (secret_file_);
    }

    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_;

    std::string secret_file_;

    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