udp_socket.h

Go to the documentation of this file.

// Copyright (C) 2011-2024 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 UDP_SOCKET_H
#define UDP_SOCKET_H 1
 
#ifndef BOOST_ASIO_HPP
#error "asio.hpp must be included before including this, see asiolink.h as to why"
#endif
 
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>             // for some IPC/network system calls
 
#include <cstddef>
 
#include <asiolink/io_asio_socket.h>
#include <asiolink/io_endpoint.h>
#include <asiolink/io_service.h>
#include <asiolink/udp_endpoint.h>
 
#include <exceptions/isc_assert.h>
 
namespace isc {
namespace asiolink {
 
template <typename C>
class UDPSocket : public IOAsioSocket<C> {
private:
    UDPSocket(const UDPSocket&);
    UDPSocket& operator=(const UDPSocket&);
 
public:
    enum {
        MIN_SIZE = 4096         // Minimum send and receive size
    };
 
    UDPSocket(boost::asio::ip::udp::socket& socket);
 
    UDPSocket(const IOServicePtr& service);
 
    virtual ~UDPSocket();
 
    virtual int getNative() const {
#if BOOST_VERSION < 106600
        return (socket_.native());
#else
        return (socket_.native_handle());
#endif
    }
 
    virtual int getProtocol() const {
        return (IPPROTO_UDP);
    }
 
    virtual bool isOpenSynchronous() const {
        return (true);
    }
 
    virtual void open(const IOEndpoint* endpoint, C& callback);
 
    virtual void asyncSend(const void* data, size_t length,
                           const IOEndpoint* endpoint, C& callback);
 
    virtual void asyncReceive(void* data, size_t length, size_t offset,
                              IOEndpoint* endpoint, C& callback);
 
    virtual bool processReceivedData(const void* staging, size_t length,
                                     size_t& cumulative, size_t& offset,
                                     size_t& expected,
                                     isc::util::OutputBufferPtr& buff);
 
    virtual void cancel();
 
    virtual void close();
 
 
private:
    IOServicePtr io_service_;
 
    // Two variables to hold the socket - a socket and a pointer to it.  This
    // handles the case where a socket is passed to the UDPSocket on
    // construction, or where it is asked to manage its own socket.
 
    std::unique_ptr<boost::asio::ip::udp::socket> socket_ptr_;
 
    // Socket
    boost::asio::ip::udp::socket& socket_;
 
    // True when socket is open
    bool isopen_;
};
 
// Constructor - caller manages socket
 
template <typename C>
UDPSocket<C>::UDPSocket(boost::asio::ip::udp::socket& socket) :
    socket_ptr_(), socket_(socket), isopen_(true) {
}
 
// Constructor - create socket on the fly
 
template <typename C>
UDPSocket<C>::UDPSocket(const IOServicePtr& io_service) : io_service_(io_service),
    socket_ptr_(new boost::asio::ip::udp::socket(io_service_->getInternalIOService())),
    socket_(*socket_ptr_), isopen_(false) {
}
 
// Destructor.
 
template <typename C>
UDPSocket<C>::~UDPSocket() {
    close();
}
 
// Open the socket.
 
template <typename C> void
UDPSocket<C>::open(const IOEndpoint* endpoint, C&) {
 
    // Ignore opens on already-open socket.  (Don't throw a failure because
    // of uncertainties as to what precedes when using asynchronous I/O.)
    // It also allows us a treat a passed-in socket in exactly the same way as
    // a self-managed socket (in that we can call the open() and close() methods
    // of this class).
    if (!isopen_) {
        if (endpoint->getFamily() == AF_INET) {
            socket_.open(boost::asio::ip::udp::v4());
        } else {
            socket_.open(boost::asio::ip::udp::v6());
        }
        isopen_ = true;
 
        // Ensure it can send and receive at least 4K buffers.
        boost::asio::ip::udp::socket::send_buffer_size snd_size;
        socket_.get_option(snd_size);
        if (snd_size.value() < MIN_SIZE) {
            snd_size = MIN_SIZE;
            socket_.set_option(snd_size);
        }
 
        boost::asio::ip::udp::socket::receive_buffer_size rcv_size;
        socket_.get_option(rcv_size);
        if (rcv_size.value() < MIN_SIZE) {
            rcv_size = MIN_SIZE;
            socket_.set_option(rcv_size);
        }
    }
}
 
// Send a message.  Should never do this if the socket is not open, so throw
// an exception if this is the case.
 
template <typename C> void
UDPSocket<C>::asyncSend(const void* data, size_t length,
                        const IOEndpoint* endpoint, C& callback) {
    if (isopen_) {
 
        // Upconvert to a UDPEndpoint.  We need to do this because although
        // IOEndpoint is the base class of UDPEndpoint and TCPEndpoint, it
        // does not contain a method for getting at the underlying endpoint
        // type - that is in the derived class and the two classes differ on
        // return type.
        isc_throw_assert(endpoint->getProtocol() == IPPROTO_UDP);
        const UDPEndpoint* udp_endpoint =
            static_cast<const UDPEndpoint*>(endpoint);
 
        // ... and send the message.
        socket_.async_send_to(boost::asio::buffer(data, length),
            udp_endpoint->getASIOEndpoint(), callback);
    } else {
        isc_throw(SocketNotOpen,
            "attempt to send on a UDP socket that is not open");
    }
}
 
// Receive a message.   Should never do this if the socket is not open, so throw
// an exception if this is the case.
 
template <typename C> void
UDPSocket<C>::asyncReceive(void* data, size_t length, size_t offset,
                           IOEndpoint* endpoint, C& callback) {
    if (isopen_) {
 
        // Upconvert the endpoint again.
        isc_throw_assert(endpoint->getProtocol() == IPPROTO_UDP);
        UDPEndpoint* udp_endpoint = static_cast<UDPEndpoint*>(endpoint);
 
        // Ensure we can write into the buffer
        if (offset >= length) {
            isc_throw(BufferOverflow, "attempt to read into area beyond end of "
                                      "UDP receive buffer");
        }
        void* buffer_start = static_cast<void*>(static_cast<uint8_t*>(data) + offset);
 
        // Issue the read
        socket_.async_receive_from(boost::asio::buffer(buffer_start, length - offset),
            udp_endpoint->getASIOEndpoint(), callback);
    } else {
        isc_throw(SocketNotOpen,
            "attempt to receive from a UDP socket that is not open");
    }
}
 
// Receive complete.  Just copy the data across to the output buffer and
// update arguments as appropriate.
 
template <typename C> bool
UDPSocket<C>::processReceivedData(const void* staging, size_t length,
                                  size_t& cumulative, size_t& offset,
                                  size_t& expected,
                                  isc::util::OutputBufferPtr& outbuff) {
    // Set return values to what we should expect.
    cumulative = length;
    expected = length;
    offset = 0;
 
    // Copy data across
    outbuff->writeData(staging, length);
 
    // ... and mark that we have everything.
    return (true);
}
 
// Cancel I/O on the socket.  No-op if the socket is not open.
 
template <typename C> void
UDPSocket<C>::cancel() {
    if (isopen_) {
        socket_.cancel();
    }
}
 
// Close the socket down.  Can only do this if the socket is open and we are
// managing it ourself.
 
template <typename C> void
UDPSocket<C>::close() {
    if (isopen_ && socket_ptr_) {
        socket_.close();
        isopen_ = false;
    }
}
 
}  // namespace asiolink
}  // namespace isc
 
#endif // UDP_SOCKET_H