tcp_connection.h

Go to the documentation of this file.

// Copyright (C) 2022-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 TCP_CONNECTION_H
#define TCP_CONNECTION_H
 
#include <asiolink/asio_wrapper.h>
#include <asiolink/interval_timer.h>
#include <asiolink/io_service.h>
#include <tcp/tcp_connection_acceptor.h>
#include <tcp/wire_data.h>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/system/error_code.hpp>
#include <boost/shared_ptr.hpp>
 
#include <array>
#include <functional>
#include <string>
#include <iostream>
 
#include <mutex>
 
namespace isc {
namespace tcp {

class TcpMessage {
public:
    virtual ~TcpMessage() = default;

    const uint8_t* getWireData() const {
        if (wire_data_.empty()) {
            isc_throw(InvalidOperation, "TcpMessage::getWireData() - cannot access empty wire data");
        }
 
        return (wire_data_.data());
    }

    size_t getWireDataSize() const {
        return (wire_data_.size());
    }
 
protected:
    WireData wire_data_;
};

class TcpRequest : public TcpMessage {
public:
    virtual ~TcpRequest(){};

    virtual size_t postBuffer(const void* buf, const size_t nbytes) = 0;

    virtual bool needData() const = 0;

    virtual std::string logFormatRequest(const size_t limit = 0) const = 0;

    virtual void unpack() = 0;
 
private:

    std::string logFormatRequestSafe(const size_t limit = 0) const;
};

typedef boost::shared_ptr<TcpRequest> TcpRequestPtr;

class TcpResponse : public TcpMessage {
public:
    TcpResponse()
    : send_in_progress_(false) {};

    virtual ~TcpResponse() {};

    bool wireDataAvail() const {
        return (!wire_data_.empty());
    }

    virtual void pack() = 0;

    virtual void consumeWireData(const size_t length);
 
    bool sendInProgress() {
        return (send_in_progress_);
    }
 
private:
    bool send_in_progress_;
};
 
typedef boost::shared_ptr<TcpResponse> TcpResponsePtr;

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

class TcpConnectionPool;

typedef std::function<bool(const boost::asio::ip::tcp::endpoint&)> TcpConnectionFilterCallback;

class TcpConnection : public boost::enable_shared_from_this<TcpConnection> {
private:

    typedef std::function<void(boost::system::error_code ec, size_t length)>
    SocketCallbackFunction;

    class SocketCallback {
    public:

        SocketCallback(SocketCallbackFunction socket_callback)
            : callback_(socket_callback) {
        }

        void operator()(boost::system::error_code ec, size_t length = 0);
 
    private:
        SocketCallbackFunction callback_;
    };
 
public:

    TcpConnection(const asiolink::IOServicePtr& io_service,
                  const TcpConnectionAcceptorPtr& acceptor,
                  const asiolink::TlsContextPtr& tls_context,
                  TcpConnectionPool& connection_pool,
                  const TcpConnectionAcceptorCallback& acceptor_callback,
                  const TcpConnectionFilterCallback& connection_filter,
                  const long idle_timeout,
                  const size_t read_max = 32768);

    virtual ~TcpConnection();

    void asyncAccept();

    virtual void shutdown();

    virtual void close();

    void doHandshake();

    void doRead(TcpRequestPtr request = TcpRequestPtr());

    TcpRequestPtr postData(TcpRequestPtr request, WireData& input_data);

    virtual void requestReceived(TcpRequestPtr request) = 0;

    virtual TcpRequestPtr createRequest() = 0;

    size_t getReadMax() const {
        return (read_max_);
    }

    void setReadMax(const size_t read_max);

    virtual bool responseSent(TcpResponsePtr response) = 0;

    static const boost::asio::ip::tcp::endpoint& NO_ENDPOINT() {
        static boost::asio::ip::tcp::endpoint endpoint;
        return (endpoint);
    }

    const boost::asio::ip::tcp::endpoint getRemoteEndpoint() const {
        return (remote_endpoint_);
    }
 
protected:

    void doWrite(TcpResponsePtr response);

    void asyncSendResponse(TcpResponsePtr response);

    void acceptorCallback(const boost::system::error_code& ec);

    void handshakeCallback(const boost::system::error_code& ec);

    void socketReadCallback(TcpRequestPtr request,
                            boost::system::error_code ec,
                            size_t length);

    virtual void socketWriteCallback(TcpResponsePtr request,
                                     boost::system::error_code ec,
                                     size_t length);

    void shutdownCallback(const boost::system::error_code& ec);

    void setupIdleTimer();

    void idleTimeoutCallback();

    virtual void shutdownConnection();

    virtual void stopThisConnection();

    std::string getRemoteEndpointAddressAsText() const;

    unsigned char* getInputBufData() {
        if (input_buf_.empty()) {
            isc_throw(InvalidOperation, "TcpConnection::getInputBufData() - cannot access empty buffer");
       }
 
        return (input_buf_.data());
    }

    size_t getInputBufSize() const {
        return (input_buf_.size());
    }

    asiolink::IOServicePtr io_service_;

    asiolink::TlsContextPtr tls_context_;

    long idle_timeout_;

    asiolink::IntervalTimer idle_timer_;

    std::unique_ptr<asiolink::TCPSocket<SocketCallback> > tcp_socket_;

    std::unique_ptr<asiolink::TLSSocket<SocketCallback> > tls_socket_;

    TcpConnectionAcceptorPtr acceptor_;

    TcpConnectionPool& connection_pool_;

    TcpConnectionAcceptorCallback acceptor_callback_;

    TcpConnectionFilterCallback connection_filter_;

    size_t read_max_;

    WireData input_buf_;

    boost::asio::ip::tcp::endpoint remote_endpoint_;
};

typedef boost::shared_ptr<TcpConnection> TcpConnectionPtr;
 
} // end of namespace isc::tcp
} // end of namespace isc
 
#endif