d2_client_mgr.h

Go to the documentation of this file.

// Copyright (C) 2014-2025 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_MGR_H
#define D2_CLIENT_MGR_H

#include <asiolink/io_address.h>
#include <dhcp_ddns/ncr_io.h>
#include <dhcpsrv/d2_client_cfg.h>
#include <dhcpsrv/srv_config.h>
#include <exceptions/exceptions.h>
#include <util/str.h>
 
#include <boost/algorithm/string.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/noncopyable.hpp>
 
#include <stdint.h>
#include <string>
#include <vector>
#include <sstream>
 
namespace isc {
namespace dhcp {

class FQDNScrubbedEmpty : public Exception {
public:
    FQDNScrubbedEmpty(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};

typedef
std::function<void(const dhcp_ddns::NameChangeSender::Result result,
                   dhcp_ddns::NameChangeRequestPtr& ncr)> D2ClientErrorHandler;

class D2ClientMgr : public dhcp_ddns::NameChangeSender::RequestSendHandler,
                    boost::noncopyable {
public:
    D2ClientMgr();

    ~D2ClientMgr();

    void setD2ClientConfig(D2ClientConfigPtr& new_config);

    bool ddnsEnabled();

    const D2ClientConfigPtr& getD2ClientConfig() const;

    void analyzeFqdn(const bool client_s, const bool client_n, bool& server_s,
                     bool& server_n, const DdnsParams& ddns_params) const;

    std::string generateFqdn(const asiolink::IOAddress& address,
                             const DdnsParams& ddns_params,
                             const bool trailing_dot = true) const;

    std::string qualifyName(const std::string& partial_name,
                            const DdnsParams& ddns_params,
                            const bool trailing_dot) const;

    template <class T>
    void adjustFqdnFlags(const T& fqdn, T& fqdn_resp,
                         const DdnsParams& ddns_params);

    template <class T>
    void getUpdateDirections(const T& fqdn_resp, bool& forward, bool& reverse);

    template <class T>
    void adjustDomainName(const T& fqdn, T& fqdn_resp,
                          const DdnsParams& ddns_params);

    void startSender(D2ClientErrorHandler error_handler,
                     const isc::asiolink::IOServicePtr& io_service);

    void startSender(D2ClientErrorHandler error_handler);

    bool amSending() const;

    void stopSender();

    void sendRequest(dhcp_ddns::NameChangeRequestPtr& ncr);

    void invokeClientErrorHandler(const dhcp_ddns::NameChangeSender::
                                  Result result,
                                  dhcp_ddns::NameChangeRequestPtr& ncr);

    size_t getQueueSize() const;

    size_t getQueueMaxSize() const;

    const dhcp_ddns::NameChangeRequestPtr& peekAt(const size_t index) const;

    void clearQueue();

    void runReadyIO();

    void suspendUpdates();

    void stop();
 
protected:
    virtual void operator ()(const dhcp_ddns::NameChangeSender::Result result,
                             dhcp_ddns::NameChangeRequestPtr& ncr);

    int getSelectFd();

    int getRegisteredSelectFd();
 
private:

    D2ClientConfigPtr d2_client_config_;

    dhcp_ddns::NameChangeSenderPtr name_change_sender_;

    boost::shared_ptr<asiolink::IOService> private_io_service_;

    D2ClientErrorHandler client_error_handler_;

    int registered_select_fd_;
};
 
template <class T>
void
D2ClientMgr::adjustFqdnFlags(const T& fqdn, T& fqdn_resp, const DdnsParams& ddns_params) {
    bool server_s = false;
    bool server_n = false;
    analyzeFqdn(fqdn.getFlag(T::FLAG_S), fqdn.getFlag(T::FLAG_N),
                server_s, server_n, ddns_params);
 
    // Reset the flags to zero to avoid triggering N and S both 1 check.
    fqdn_resp.resetFlags();
 
    // Set S and N flags.
    fqdn_resp.setFlag(T::FLAG_S, server_s);
    fqdn_resp.setFlag(T::FLAG_N, server_n);
 
    // Set O flag true if server S overrides client S.
    fqdn_resp.setFlag(T::FLAG_O, (fqdn.getFlag(T::FLAG_S) != server_s));
}
 
template <class T>
void
D2ClientMgr::getUpdateDirections(const T& fqdn_resp,
                                 bool& forward, bool& reverse) {
    forward = fqdn_resp.getFlag(T::FLAG_S);
    reverse = !(fqdn_resp.getFlag(T::FLAG_N));
}
 
template <class T>
void
D2ClientMgr::adjustDomainName(const T& fqdn, T& fqdn_resp, const DdnsParams& ddns_params) {
    // If we're configured to replace it or the supplied name is blank
    // set the response name to blank.
    D2ClientConfig::ReplaceClientNameMode mode = ddns_params.getReplaceClientNameMode();
    if ((mode == D2ClientConfig::RCM_ALWAYS || mode == D2ClientConfig::RCM_WHEN_PRESENT) ||
        fqdn.getDomainName().empty()) {
        fqdn_resp.setDomainName("", T::PARTIAL);
    } else {
        // Sanitize the name the client sent us, if we're configured to do so.
        std::string client_name = fqdn.getDomainName();
        isc::util::str::StringSanitizerPtr sanitizer = ddns_params.getHostnameSanitizer();
        if (sanitizer) {
            // We need the raw text form, so we can replace escaped chars
            dns::Name tmp(client_name);
            std::string raw_name = tmp.toRawText();
 
            // We do not know if the sanitizer's regexp preserves dots, so
            // we'll scrub it label by label. Yeah, lucky us.
            // Using boost::split is simpler than using dns::Name::split() as
            // that returns Names which have trailing dots etc.
            std::vector<std::string> labels;
            boost::algorithm::split(labels, raw_name, boost::is_any_of("."));
            std::stringstream ss;
            bool first = true;
            for (auto const& label : labels) {
                if (!first) {
                    ss << ".";
                } else {
                    first = false;
                }
 
                ss << sanitizer->scrub(label);
            }
 
            std::string clean_name = ss.str();
            if (clean_name.empty() || clean_name == ".") {
                isc_throw(FQDNScrubbedEmpty, client_name);
            }
 
            client_name = clean_name;
        }
 
        // If the supplied name is partial, qualify it by adding the suffix.
        if (fqdn.getDomainNameType() == T::PARTIAL) {
            if (client_name.back() == '.') {
                // By definition a partial cannot end in a dot, sanitizing above
                // may have added one.  Strip it, so we'll add the suffix (if one).
                client_name.pop_back();
            }
 
            fqdn_resp.setDomainName(qualifyName(client_name, ddns_params, true), T::FULL);
        } else  {
            fqdn_resp.setDomainName(client_name, T::FULL);
        }
    }
}
 

typedef boost::shared_ptr<D2ClientMgr> D2ClientMgrPtr;
 
 
} // namespace isc
} // namespace dhcp
 
#endif