ncr_io.h

Go to the documentation of this file.

// Copyright (C) 2013-2026 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 NCR_IO_H
#define NCR_IO_H

 
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <dhcp_ddns/ncr_msg.h>
#include <exceptions/exceptions.h>
 
#include <cstdint>
#include <deque>
#include <mutex>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/scoped_ptr.hpp>
 
namespace isc {
namespace dhcp_ddns {

enum NameChangeProtocol : uint16_t {
  NCR_UDP,
  NCR_TCP
};

extern NameChangeProtocol stringToNcrProtocol(const std::string& protocol_str);

extern std::string ncrProtocolToString(NameChangeProtocol protocol);

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

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

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

class NameChangeListener {
public:

    enum Result : uint16_t {
        SUCCESS,
        TIME_OUT,
        STOPPED,
        ERROR
    };

    class RequestReceiveHandler : public boost::enable_shared_from_this<RequestReceiveHandler> {
    public:

        virtual void operator()(const Result result,
                                NameChangeRequestPtr& ncr) = 0;
 
        virtual ~RequestReceiveHandler() {
        }
    };

    typedef boost::shared_ptr<RequestReceiveHandler> RequestReceiveHandlerPtr;

    NameChangeListener(RequestReceiveHandlerPtr recv_handler);

    virtual ~NameChangeListener() {
    }

    void startListening(const isc::asiolink::IOServicePtr& io_service);

    void stopListening();
 
protected:

    void receiveNext();

    void invokeRecvHandler(const Result result, NameChangeRequestPtr& ncr);

    void scheduleNextReceive();

    virtual void open(const isc::asiolink::IOServicePtr& io_service) = 0;

    virtual void close() = 0;

    virtual void doReceive() = 0;
 
public:

    bool amListening() const {
        return (listening_);
    }

    bool isIoPending() const {
        return (io_pending_);
    }
 
private:
    void setListening(bool value) {
        listening_ = value;
    }

    bool listening_;

    bool io_pending_;

    RequestReceiveHandlerPtr recv_handler_;
};

typedef boost::shared_ptr<NameChangeListener> NameChangeListenerPtr;

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

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

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

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



class NameChangeSender {
public:

    typedef std::deque<NameChangeRequestPtr> SendQueue;

    static const size_t MAX_QUEUE_DEFAULT = 1024;

    enum Result : uint16_t {
        SUCCESS = 0,
        TIME_OUT = 1,
        STOPPED = 2,
        ERROR = 3,
    };

    static std::string const& resultToText(Result const& result) {
        static std::vector<std::string> const text_vector {
            "SUCCESS",
            "TIME_OUT",
            "STOPPED",
            "ERROR",
        };
        static std::string const unknown("UNKNOWN");
        return (result < text_vector.size() ? text_vector[result] : unknown);
    }

    class RequestSendHandler : public boost::enable_shared_from_this<RequestSendHandler> {
    public:

        virtual void operator ()(const Result result,
                                 NameChangeRequestPtr& ncr) = 0;
 
        virtual ~RequestSendHandler() {
        }
    };

    typedef boost::shared_ptr<RequestSendHandler> RequestSendHandlerPtr;

    NameChangeSender(RequestSendHandlerPtr send_handler,
                     size_t send_queue_max = MAX_QUEUE_DEFAULT);

    virtual ~NameChangeSender() {
    }

    void startSending(const isc::asiolink::IOServicePtr& io_service);

    void stopSending();

    void sendRequest(NameChangeRequestPtr& ncr);

    void assumeQueue(NameChangeSender& source_sender);

    virtual int getSelectFd() = 0;

    virtual bool ioReady() = 0;
 
private:

    void startSendingInternal(const isc::asiolink::IOServicePtr& io_service);

    void sendRequestInternal(NameChangeRequestPtr& ncr);

    void assumeQueueInternal(NameChangeSender& source_sender);

    void invokeSendHandlerInternal(const NameChangeSender::Result result);

    void skipNextInternal();

    size_t getQueueSizeInternal() const;

    const NameChangeRequestPtr& peekAtInternal(const size_t index) const;
 
protected:

    void sendNext();

    void invokeSendHandler(const NameChangeSender::Result result);

    virtual void open(const isc::asiolink::IOServicePtr& io_service) = 0;

    virtual void close() = 0;

    virtual void doSend(NameChangeRequestPtr& ncr) = 0;
 
public:

    void skipNext();

    void clearSendQueue();

    bool amSending() const {
        return (sending_);
    }

    bool isSendInProgress() const;

    size_t getQueueMaxSize() const  {
        return (send_queue_max_);
    }

    void setQueueMaxSize(const size_t new_max);

    size_t getQueueSize() const;

    const NameChangeRequestPtr& peekAt(const size_t index) const;

    virtual void runReadyIO();
 
protected:

    SendQueue& getSendQueue() {
        return (send_queue_);
    }
 
private:

    void setSending(bool value) {
        sending_ = value;
    }
 
protected:

    asiolink::IOServicePtr io_service_;
 
private:

    bool sending_;

    RequestSendHandlerPtr send_handler_;

    size_t send_queue_max_;

    SendQueue send_queue_;

    NameChangeRequestPtr ncr_to_send_;

    const boost::scoped_ptr<std::mutex> mutex_;
};

typedef boost::shared_ptr<NameChangeSender> NameChangeSenderPtr;
 
}  // namespace dhcp_ddns
}  // namespace isc
 
#endif