d2_client_mgr.h

Go to the documentation of this file.

// Copyright (C) 2014-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_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 <exceptions/exceptions.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 {
 
typedef
boost::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;
 
    std::string generateFqdn(const asiolink::IOAddress& address,
                             const bool trailing_dot = true) const;
 
    std::string qualifyName(const std::string& partial_name,
                            const bool trailing_dot) const;
 
    template <class T>
    void adjustFqdnFlags(const T& fqdn, T& fqdn_resp);
 
    template <class T>
    void getUpdateDirections(const T& fqdn_resp, bool& forward, bool& reverse);
 
    template <class T>
    void adjustDomainName(const T& fqdn, T& fqdn_resp);
 
    void startSender(D2ClientErrorHandler error_handler,
                     isc::asiolink::IOService& 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();
 
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) {
    bool server_s = false;
    bool server_n = false;
    analyzeFqdn(fqdn.getFlag(T::FLAG_S), fqdn.getFlag(T::FLAG_N),
                server_s, server_n);
 
    // 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) {
    // If we're configured to replace it or the supplied name is blank
    // set the response name to blank.
    if ((d2_client_config_->getReplaceClientNameMode() == D2ClientConfig::RCM_ALWAYS ||
         d2_client_config_->getReplaceClientNameMode() == 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();
 
        if (d2_client_config_->getHostnameSanitizer()) {
            // 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;
            for (auto label = labels.begin(); label != labels.end(); ++label ) {
                if (label != labels.begin()) {
                    ss << ".";
                }
 
                ss << d2_client_config_->getHostnameSanitizer()->scrub(*label);
            }
 
            client_name = ss.str();
        }
 
        // If the supplied name is partial, qualify it by adding the suffix.
        if (fqdn.getDomainNameType() == T::PARTIAL) {
            fqdn_resp.setDomainName(qualifyName(client_name,true), T::FULL);
        }
        else  {
            fqdn_resp.setDomainName(client_name, T::FULL);
        }
    }
}
 
typedef boost::shared_ptr<D2ClientMgr> D2ClientMgrPtr;
 
 
} // namespace isc
} // namespace dhcp
 
#endif