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