connection.h

Go to the documentation of this file.

// Copyright (C) 2017-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 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 (!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(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();
 
    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;
 
    void markWatchSocketReady();
 
    void clearWatchSocket();
 
    void closeWatchSocket();
 
    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_;
};
 
} // end of namespace isc::http
} // end of namespace isc
 
#endif