connection.h

Go to the documentation of this file.

// Copyright (C) 2017-2021 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 <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 (!output_buf_.empty());
        }

        const char* getOutputBufData() const {
            return (output_buf_.data());
        }

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

        void setOutputBuf(const std::string& response) {
            output_buf_ = response;
        }

        void consumeOutputBuf(const size_t length) {
            output_buf_.erase(0, length);
        }

    private:

        HttpRequestPtr request_;

        HttpRequestParserPtr parser_;

        std::array<char, 32768> input_buf_;

        std::string output_buf_;
    };

public:

    HttpConnection(asiolink::IOService& io_service,
                   const HttpAcceptorPtr& acceptor,
                   const asiolink::TlsContextPtr& tls_context,
                   HttpConnectionPool& connection_pool,
                   const HttpResponseCreatorPtr& response_creator,
                   const HttpAcceptorCallback& callback,
                   const long request_timeout,
                   const long idle_timeout);

    virtual ~HttpConnection();

    void asyncAccept();

    void shutdown();

    void close();


    void doHandshake();

    void doRead(TransactionPtr transaction = TransactionPtr());

protected:

    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);

    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;

    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_;

    HttpConnectionPool& connection_pool_;

    HttpResponseCreatorPtr response_creator_;

    HttpAcceptorCallback acceptor_callback_;
};

} // end of namespace isc::http
} // end of namespace isc

#endif