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 <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 {
 
typedef std::vector<uint8_t> WireData;
typedef boost::shared_ptr<WireData> WireDataPtr;
 
class TcpMessage {
public:
    virtual ~TcpMessage(){
    };
 
    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