ncr_udp.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 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_UDP_LISTENER_H
#define NCR_UDP_LISTENER_H


#include <asiolink/asio_wrapper.h>
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <asiolink/udp_endpoint.h>
#include <asiolink/udp_socket.h>
#include <dhcp_ddns/ncr_io.h>
#include <util/buffer.h>
#include <util/watch_socket.h>

#include <boost/shared_array.hpp>


namespace isc {
namespace dhcp_ddns {

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

class UDPCallback;
typedef std::function<void(const bool, const UDPCallback*)>
          UDPCompletionHandler;

typedef boost::shared_array<uint8_t> RawBufferPtr;

typedef boost::shared_ptr<asiolink::UDPEndpoint> UDPEndpointPtr;

class UDPCallback {

public:
    struct Data {

        Data(RawBufferPtr& buffer, const size_t buf_size,
             UDPEndpointPtr& data_source)
            : buffer_(buffer), buf_size_(buf_size), data_source_(data_source),
              put_len_(0), error_code_(), bytes_transferred_(0) {
        };

        RawBufferPtr buffer_;

        size_t buf_size_;

        UDPEndpointPtr data_source_;

        size_t put_len_;

        boost::system::error_code error_code_;

        size_t bytes_transferred_;

    };

    UDPCallback (RawBufferPtr& buffer, const size_t buf_size,
                 UDPEndpointPtr& data_source,
                 const UDPCompletionHandler& handler);

    void operator ()(const boost::system::error_code error_code,
                     const size_t bytes_transferred);

    size_t getBytesTransferred() const {
        return (data_->bytes_transferred_);
    }

    void setBytesTransferred(const size_t value) {
        data_->bytes_transferred_ = value;
    }

    boost::system::error_code getErrorCode() const {
        return (data_->error_code_);
    }

    void setErrorCode(const boost::system::error_code value) {
        data_->error_code_  = value;
    }

    RawBufferPtr getBuffer() const {
        return (data_->buffer_);
    }

    size_t getBufferSize() const {
        return (data_->buf_size_);
    }

    const uint8_t* getData() const {
        return (data_->buffer_.get());
    }

    void putData(const uint8_t* src, size_t len);

    size_t getPutLen() const {
        return (data_->put_len_);
    }

    void setDataSource(UDPEndpointPtr& endpoint) {
        data_->data_source_ = endpoint;
    }

    const UDPEndpointPtr& getDataSource() {
        return (data_->data_source_);
    }

  private:
    UDPCompletionHandler handler_;

    boost::shared_ptr<Data> data_;
};

typedef isc::asiolink::UDPSocket<UDPCallback> NameChangeUDPSocket;

class NameChangeUDPListener : public NameChangeListener {
public:
    static const size_t RECV_BUF_MAX = isc::asiolink::
                                       UDPSocket<UDPCallback>::MIN_SIZE;

    NameChangeUDPListener(const isc::asiolink::IOAddress& ip_address,
                          const uint32_t port,
                          const NameChangeFormat format,
                          RequestReceiveHandler& ncr_recv_handler,
                          const bool reuse_address = false);

    virtual ~NameChangeUDPListener();

    virtual void open(isc::asiolink::IOService& io_service);

    virtual void close();

    void doReceive();

    void receiveCompletionHandler(const bool successful,
                                  const UDPCallback* recv_callback);
private:
    isc::asiolink::IOAddress ip_address_;

    uint32_t port_;

    NameChangeFormat format_;

    boost::shared_ptr<boost::asio::ip::udp::socket> asio_socket_;

    boost::shared_ptr<NameChangeUDPSocket> socket_;

    boost::shared_ptr<UDPCallback> recv_callback_;

    bool reuse_address_;

private:
    NameChangeUDPListener(const NameChangeUDPListener& source);
    NameChangeUDPListener& operator=(const NameChangeUDPListener& source);
};


class NameChangeUDPSender : public NameChangeSender {
public:

    static const size_t SEND_BUF_MAX =  NameChangeUDPListener::RECV_BUF_MAX;

    NameChangeUDPSender(const isc::asiolink::IOAddress& ip_address,
        const uint32_t port, const isc::asiolink::IOAddress& server_address,
        const uint32_t server_port, const NameChangeFormat format,
        RequestSendHandler& ncr_send_handler,
        const size_t send_que_max = NameChangeSender::MAX_QUEUE_DEFAULT,
        const bool reuse_address = false);

    virtual ~NameChangeUDPSender();


    virtual void open(isc::asiolink::IOService& io_service);


    virtual void close();

    virtual void doSend(NameChangeRequestPtr& ncr);

    void sendCompletionHandler(const bool successful,
                               const UDPCallback* send_callback);

    virtual int getSelectFd();

    virtual bool ioReady();

private:

    void closeWatchSocket();

    isc::asiolink::IOAddress ip_address_;

    uint32_t port_;

    isc::asiolink::IOAddress server_address_;

    uint32_t server_port_;

    NameChangeFormat format_;

    boost::shared_ptr<boost::asio::ip::udp::socket> asio_socket_;

    boost::shared_ptr<NameChangeUDPSocket> socket_;

    boost::shared_ptr<isc::asiolink::UDPEndpoint> server_endpoint_;

    boost::shared_ptr<UDPCallback> send_callback_;

    bool reuse_address_;

    util::WatchSocketPtr watch_socket_;
};

} // namespace isc::dhcp_ddns
} // namespace isc

#endif