tcp_socket.h

Go to the documentation of this file.

// Copyright (C) 2011-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 TCP_SOCKET_H
#define TCP_SOCKET_H
 
#ifndef BOOST_ASIO_HPP
#error "asio.hpp must be included before including this, see asiolink.h as to why"
#endif
 
#include <asiolink/io_asio_socket.h>
#include <asiolink/io_endpoint.h>
#include <asiolink/io_service.h>
#include <asiolink/tcp_endpoint.h>
#include <exceptions/isc_assert.h>
#include <util/buffer.h>
#include <util/io.h>
 
#include <algorithm>
#include <cstddef>
#include <vector>
 
#include <boost/numeric/conversion/cast.hpp>
 
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>             // for some IPC/network system calls
 
namespace isc {
namespace asiolink {

class BufferTooLarge : public IOError {
public:
    BufferTooLarge(const char* file, size_t line, const char* what) :
        IOError(file, line, what) {}
};

template <typename C>
class TCPSocket : public IOAsioSocket<C> {
private:
    TCPSocket(const TCPSocket&);
    TCPSocket& operator=(const TCPSocket&);
 
public:

    TCPSocket(boost::asio::ip::tcp::socket& socket);

    TCPSocket(const IOServicePtr& service);

    virtual ~TCPSocket();

    virtual int getNative() const {
        return (socket_.native_handle());
    }

    virtual int getProtocol() const {
        return (IPPROTO_TCP);
    }

    virtual bool isOpenSynchronous() const {
        return (false);
    }

    bool isUsable() const {
        // If the socket is open it doesn't mean that it is still usable. The connection
        // could have been closed on the other end. We have to check if we can still
        // use this socket.
        if (socket_.is_open()) {
            // Remember the current non blocking setting.
            const bool non_blocking_orig = socket_.non_blocking();
            // Set the socket to non blocking mode. We're going to test if the socket
            // returns would_block status on the attempt to read from it.
            socket_.non_blocking(true);
 
            boost::system::error_code ec;
            char data[2];
 
            // Use receive with message peek flag to avoid removing the data awaiting
            // to be read.
            static_cast<void>(
                socket_.receive(boost::asio::buffer(data, sizeof(data)),
                                boost::asio::socket_base::message_peek,
                                ec));
 
            // Revert the original non_blocking flag on the socket.
            socket_.non_blocking(non_blocking_orig);
 
            // If the connection is alive we'd typically get would_block status code.
            // If there are any data that haven't been read we may also get success
            // status. We're guessing that try_again may also be returned by some
            // implementations in some situations. Any other error code indicates a
            // problem with the connection so we assume that the connection has been
            // closed.
            return (!ec || (ec.value() == boost::asio::error::try_again) ||
                    (ec.value() == boost::asio::error::would_block));
        }
 
        return (false);
    }

    virtual void open(const IOEndpoint* endpoint, C& callback);

    virtual void asyncSend(const void* data, size_t length,
                           const IOEndpoint* endpoint, C& callback);

    void asyncSend(const void* data, size_t length, 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();

    virtual boost::asio::ip::tcp::socket& getASIOSocket() const {
        return (socket_);
    }
 
private:

    IOServicePtr io_service_;


    std::unique_ptr<boost::asio::ip::tcp::socket> socket_ptr_;

    boost::asio::ip::tcp::socket& socket_;

    isc::util::OutputBufferPtr header_;
};
 
// Constructor - caller manages socket
 
template <typename C>
TCPSocket<C>::TCPSocket(boost::asio::ip::tcp::socket& socket) :
    socket_ptr_(), socket_(socket), header_() {
}
 
// Constructor - create socket on the fly
 
template <typename C>
TCPSocket<C>::TCPSocket(const IOServicePtr& io_service) : io_service_(io_service),
    socket_ptr_(new boost::asio::ip::tcp::socket(io_service_->getInternalIOService())),
    socket_(*socket_ptr_) {
}
 
// Destructor.
 
template <typename C>
TCPSocket<C>::~TCPSocket() {
    TCPSocket<C>::close();
}
 
// Open the socket.
 
template <typename C> void
TCPSocket<C>::open(const IOEndpoint* endpoint, C& callback) {
    // If socket is open on this end but has been closed by the peer,
    // we need to reconnect.
    if (socket_.is_open() && !isUsable()) {
        close();
    }
    // Ignore opens on already-open socket.  Don't throw a failure because
    // of uncertainties as to what precedes when using asynchronous I/O.
    // Also allows us a treat a passed-in socket as a self-managed socket.
    if (!socket_.is_open()) {
        if (endpoint->getFamily() == AF_INET) {
            socket_.open(boost::asio::ip::tcp::v4());
        } else {
            socket_.open(boost::asio::ip::tcp::v6());
        }
 
        // Set options on the socket:
 
        // Reuse address - allow the socket to bind to a port even if the port
        // is in the TIMED_WAIT state.
        socket_.set_option(boost::asio::socket_base::reuse_address(true));
    }
 
    // Upconvert to a TCPEndpoint.  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
    isc_throw_assert(endpoint->getProtocol() == IPPROTO_TCP);
    const TCPEndpoint* tcp_endpoint =
        static_cast<const TCPEndpoint*>(endpoint);
 
    // Connect to the remote endpoint.  On success, the handler will be
    // called (with one argument - the length argument will default to
    // zero).
    socket_.async_connect(tcp_endpoint->getASIOEndpoint(), callback);
}
 
// Send a message.  Should never do this if the socket is not open, so throw
// an exception if this is the case.
//
// This uses boost asio buffers which do not own the data so it is
// the responsibility of the caller to keep the data valid.
// The header holding the count is a member of the socket object.
// Boost asio buffers themselves can be released after boot asio calls.
 
template <typename C> void
TCPSocket<C>::asyncSend(const void* data, size_t length, C& callback) {
    if (socket_.is_open()) {
        // Send the data.
        socket_.async_send(boost::asio::buffer(data, length), callback);
    } else {
        isc_throw(SocketNotOpen,
            "attempt to send on a TCP socket that is not open");
    }
}
 
template <typename C> void
TCPSocket<C>::asyncSend(const void* data, size_t length,
    const IOEndpoint*, C& callback) {
    if (socket_.is_open()) {

        try {
            uint16_t count = boost::numeric_cast<uint16_t>(length);
            header_.reset(new isc::util::OutputBuffer(2));
            header_->writeUint16(count);
            std::vector<boost::asio::const_buffer> buffers;
 
            // Prepare a buffer sequence.
            buffers.push_back(boost::asio::buffer(header_->getData(),
                                                  header_->getLength()));
            buffers.push_back(boost::asio::buffer(data, length));

            socket_.async_send(buffers, callback);
        } catch (const boost::numeric::bad_numeric_cast&) {
            isc_throw(BufferTooLarge,
                      "attempt to send buffer larger than 64kB");
        }
 
    } else {
        isc_throw(SocketNotOpen,
            "attempt to send on a TCP socket that is not open");
    }
}
 
// Receive a message. Note that the "offset" argument is used as an index
// into the buffer in order to decide where to put the data.  It is up to the
// caller to initialize the data to zero
template <typename C> void
TCPSocket<C>::asyncReceive(void* data, size_t length, size_t offset,
    IOEndpoint* endpoint, C& callback) {
    if (socket_.is_open()) {
        // Upconvert to a TCPEndpoint.  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_TCP);
        TCPEndpoint* tcp_endpoint = static_cast<TCPEndpoint*>(endpoint);
 
        // Write the endpoint details from the communications link.  Ideally
        // we should make IOEndpoint assignable, but this runs in to all sorts
        // of problems concerning the management of the underlying Boost
        // endpoint (e.g. if it is not self-managed, is the copied one
        // self-managed?) The most pragmatic solution is to let Boost take care
        // of everything and copy details of the underlying endpoint.
        tcp_endpoint->getASIOEndpoint() = socket_.remote_endpoint();
 
        // Ensure we can write into the buffer and if so, set the pointer to
        // where the data will be written.
        if (offset >= length) {
            isc_throw(BufferOverflow, "attempt to read into area beyond end of "
                                      "TCP receive buffer");
        }
        void* buffer_start = static_cast<void*>(static_cast<uint8_t*>(data) + offset);
 
        // ... and kick off the read.
        socket_.async_receive(boost::asio::buffer(buffer_start, length - offset), callback);
 
    } else {
        isc_throw(SocketNotOpen,
            "attempt to receive from a TCP socket that is not open");
    }
}
 
// Is the receive complete?
 
template <typename C> bool
TCPSocket<C>::processReceivedData(const void* staging, size_t length,
                                  size_t& cumulative, size_t& offset,
                                  size_t& expected,
                                  isc::util::OutputBufferPtr& outbuff) {
    // Point to the data in the staging buffer and note how much there is.
    const uint8_t* data = static_cast<const uint8_t*>(staging);
    size_t data_length = length;
 
    // Is the number is "expected" valid?  It won't be unless we have received
    // at least two bytes of data in total for this set of receives.
    if (cumulative < 2) {
 
        // "expected" is not valid.  Did this read give us enough data to
        // work it out?
        cumulative += length;
        if (cumulative < 2) {
 
            // Nope, still not valid.  This must have been the first packet and
            // was only one byte long.  Tell the fetch code to read the next
            // packet into the staging buffer beyond the data that is already
            // there so that the next time we are called we have a complete
            // TCP count.
            offset = cumulative;
            return (false);
        }
 
        // Have enough data to interpret the packet count, so do so now.
        expected = isc::util::readUint16(data, cumulative);
 
        // We have two bytes less of data to process.  Point to the start of the
        // data and adjust the packet size.  Note that at this point,
        // "cumulative" is the true amount of data in the staging buffer, not
        // "length".
        data += 2;
        data_length = cumulative - 2;
    } else {
 
        // Update total amount of data received.
        cumulative += length;
    }
 
    // Regardless of anything else, the next read goes into the start of the
    // staging buffer.
    offset = 0;
 
    // Work out how much data we still have to put in the output buffer. (This
    // could be zero if we have just interpreted the TCP count and that was
    // set to zero.)
    if (expected >= outbuff->getLength()) {
 
        // Still need data in the output packet.  Copy what we can from the
        // staging buffer to the output buffer.
        size_t copy_amount = std::min(expected - outbuff->getLength(), data_length);
        outbuff->writeData(data, copy_amount);
    }
 
    // We can now say if we have all the data.
    return (expected == outbuff->getLength());
}
 
// Cancel I/O on the socket.  No-op if the socket is not open.
 
template <typename C> void
TCPSocket<C>::cancel() {
    if (socket_.is_open()) {
        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
TCPSocket<C>::close() {
    if (socket_.is_open() && socket_ptr_) {
        socket_.close();
    }
}
 
}  // namespace asiolink
}  // namespace isc
 
#endif // TCP_SOCKET_H