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