connection.h

Go to the documentation of this file.

// Copyright (C) 2017-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 HTTP_CONNECTION_H
#define HTTP_CONNECTION_H
 
#include <asiolink/interval_timer.h>
#include <asiolink/io_service.h>
#include <http/http_acceptor.h>
#include <http/request_parser.h>
#include <http/response_creator_factory.h>
#include <util/watch_socket.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>
 
namespace isc {
namespace http {

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

class HttpConnectionPool;
 
class HttpConnection;
typedef boost::shared_ptr<HttpConnection> HttpConnectionPtr;

class HttpConnection : public boost::enable_shared_from_this<HttpConnection> {
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_;
    };
 
protected:
 
    class Transaction;

    typedef boost::shared_ptr<Transaction> TransactionPtr;

    class Transaction {
    public:

        Transaction(const HttpResponseCreatorPtr& response_creator,
                    const HttpRequestPtr& request = HttpRequestPtr());

        static TransactionPtr create(const HttpResponseCreatorPtr& response_creator);

        static TransactionPtr spawn(const HttpResponseCreatorPtr& response_creator,
                                    const TransactionPtr& transaction);

        HttpRequestPtr getRequest() const {
            return (request_);
        }

        HttpRequestParserPtr getParser() const {
            return (parser_);
        }

        char* getInputBufData() {
            return (input_buf_.data());
        }

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

        bool outputDataAvail() const {
            return (position_ < output_buf_.size());
        }

        const char* getOutputBufData() const {
            return (&output_buf_[position_]);
        }

        size_t getOutputBufSize() const {
            return (output_buf_.size() - position_);
        }

        void setOutputBuf(const std::string& response) {
            if (response.empty()) {
                isc_throw(Unexpected, "empty response");
            }
            output_buf_ = response;
        }

        void consumeOutputBuf(const size_t length) {
            if (length >= output_buf_.size() - position_) {
                position_ = output_buf_.size();
            } else {
                position_ += length;
            }
        }
 
    private:

        HttpRequestPtr request_;

        HttpRequestParserPtr parser_;

        std::array<char, 32768> input_buf_;

        std::string output_buf_;

        size_t position_;
    };
 
public:

    HttpConnection(const asiolink::IOServicePtr& io_service,
                   const HttpAcceptorPtr& acceptor,
                   const asiolink::TlsContextPtr& tls_context,
                   std::shared_ptr<HttpConnectionPool> connection_pool,
                   const HttpResponseCreatorPtr& response_creator,
                   const HttpAcceptorCallback& callback,
                   const long request_timeout,
                   const long idle_timeout);

    virtual ~HttpConnection();

    void addExternalSockets(bool use_external = false);

    void asyncAccept();

    void shutdown();

    void close();

    void recordParameters(const HttpRequestPtr& request) const;

    void doHandshake();

    virtual void doRead(TransactionPtr transaction = TransactionPtr());
 
protected:

    virtual void doWrite(TransactionPtr transaction);

    void asyncSendResponse(const ConstHttpResponsePtr& response,
                           TransactionPtr transaction);

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

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

    virtual void socketReadCallback(TransactionPtr transaction,
                                    boost::system::error_code ec,
                                    size_t length);

    virtual void socketWriteCallback(TransactionPtr transaction,
                                     boost::system::error_code ec,
                                     size_t length);

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

    void setupRequestTimer(TransactionPtr transaction = TransactionPtr());

    void setupIdleTimer();

    void requestTimeoutCallback(TransactionPtr transaction);
 
    void idleTimeoutCallback();

    void shutdownConnection();

    void stopThisConnection();

    std::string getRemoteEndpointAddressAsText() const;

    void markWatchSocketReady();

    void clearWatchSocket();

    void closeWatchSocket();

    asiolink::IOServicePtr io_service_;

    asiolink::IntervalTimer request_timer_;

    long request_timeout_;

    asiolink::TlsContextPtr tls_context_;

    long idle_timeout_;

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

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

    HttpAcceptorPtr acceptor_;

    std::weak_ptr<HttpConnectionPool> connection_pool_;

    HttpResponseCreatorPtr response_creator_;

    HttpAcceptorCallback acceptor_callback_;

    bool use_external_;

    util::WatchSocketPtr watch_socket_;

    bool defer_shutdown_;

    bool closed_;

    bool registered_;
};
 
} // end of namespace isc::http
} // end of namespace isc
 
#endif