HttpConnection.h

Go to the documentation of this file.

#pragma once
#include <aws/http/connection.h>
#include <aws/http/proxy.h>
#include <aws/http/request_response.h>
 
#include <aws/crt/Types.h>
#include <aws/crt/io/Bootstrap.h>
#include <aws/crt/io/SocketOptions.h>
#include <aws/crt/io/Stream.h>
#include <aws/crt/io/TlsOptions.h>
 
#include <functional>
#include <memory>
 
namespace Aws
{
    namespace Crt
    {
        namespace Io
        {
            class ClientBootstrap;
            class L4ProxyConfig;
        } // namespace Io
 
        namespace Http
        {
            class HttpClientConnection;
            class HttpStream;
            class HttpClientStream;
            class HttpRequest;
            class HttpProxyStrategy;
            using HttpHeader = aws_http_header;
 
            using OnConnectionSetup =
                std::function<void(const std::shared_ptr<HttpClientConnection> &connection, int errorCode)>;
 
            using OnConnectionShutdown = std::function<void(HttpClientConnection &connection, int errorCode)>;
 
            using OnIncomingHeaders = std::function<void(
                HttpStream &stream,
                enum aws_http_header_block headerBlock,
                const HttpHeader *headersArray,
                std::size_t headersCount)>;
 
            using OnIncomingHeadersBlockDone =
                std::function<void(HttpStream &stream, enum aws_http_header_block block)>;
 
            using OnIncomingBody = std::function<void(HttpStream &stream, const ByteCursor &data)>;
 
            using OnStreamComplete = std::function<void(HttpStream &stream, int errorCode)>;
 
            struct AWS_CRT_CPP_API HttpRequestOptions
            {
                HttpRequest *request;
 
                OnIncomingHeaders onIncomingHeaders;
                OnIncomingHeadersBlockDone onIncomingHeadersBlockDone;
 
                OnIncomingBody onIncomingBody;
 
                OnStreamComplete onStreamComplete;
 
                bool UseManualDataWrites = false;
            };
 
            class AWS_CRT_CPP_API HttpStream : public std::enable_shared_from_this<HttpStream>
            {
              public:
                virtual ~HttpStream();
                HttpStream(const HttpStream &) = delete;
                HttpStream(HttpStream &&) = delete;
                HttpStream &operator=(const HttpStream &) = delete;
                HttpStream &operator=(HttpStream &&) = delete;
 
                HttpClientConnection &GetConnection() const noexcept;
 
                virtual int GetResponseStatusCode() const noexcept = 0;
 
                void UpdateWindow(std::size_t incrementSize) noexcept;
 
              protected:
                aws_http_stream *m_stream;
                std::shared_ptr<HttpClientConnection> m_connection;
                HttpStream(const std::shared_ptr<HttpClientConnection> &connection) noexcept;
 
              private:
                OnIncomingHeaders m_onIncomingHeaders;
                OnIncomingHeadersBlockDone m_onIncomingHeadersBlockDone;
                OnIncomingBody m_onIncomingBody;
                OnStreamComplete m_onStreamComplete;
 
                static int s_onIncomingHeaders(
                    struct aws_http_stream *stream,
                    enum aws_http_header_block headerBlock,
                    const struct aws_http_header *headerArray,
                    size_t numHeaders,
                    void *userData) noexcept;
                static int s_onIncomingHeaderBlockDone(
                    struct aws_http_stream *stream,
                    enum aws_http_header_block headerBlock,
                    void *userData) noexcept;
                static int s_onIncomingBody(
                    struct aws_http_stream *stream,
                    const struct aws_byte_cursor *data,
                    void *userData) noexcept;
                static void s_onStreamComplete(struct aws_http_stream *stream, int errorCode, void *userData) noexcept;
 
                friend class HttpClientConnection;
            };
 
            struct ClientStreamCallbackData
            {
                ClientStreamCallbackData() : allocator(nullptr), stream(nullptr) {}
                Allocator *allocator;
                std::shared_ptr<HttpStream> stream;
            };
 
            using OnWriteDataComplete = std::function<void(std::shared_ptr<HttpStream> &stream, int errorCode)>;
 
            class AWS_CRT_CPP_API HttpClientStream final : public HttpStream
            {
              public:
                ~HttpClientStream();
                HttpClientStream(const HttpClientStream &) = delete;
                HttpClientStream(HttpClientStream &&) = delete;
                HttpClientStream &operator=(const HttpClientStream &) = delete;
                HttpClientStream &operator=(HttpClientStream &&) = delete;
 
                virtual int GetResponseStatusCode() const noexcept override;
 
                bool Activate() noexcept;
 
                int WriteData(
                    std::shared_ptr<Aws::Crt::Io::InputStream> stream,
                    const OnWriteDataComplete &onComplete,
                    bool endStream = false) noexcept;
 
              private:
                HttpClientStream(const std::shared_ptr<HttpClientConnection> &connection) noexcept;
 
                ClientStreamCallbackData m_callbackData;
                friend class HttpClientConnection;
            };
 
            enum class AwsHttpProxyAuthenticationType
            {
                None,
                Basic,
            };
 
            enum class AwsHttpProxyConnectionType
            {
                Legacy = AWS_HPCT_HTTP_LEGACY,
 
                Forwarding = AWS_HPCT_HTTP_FORWARD,
 
                Tunneling = AWS_HPCT_HTTP_TUNNEL,
            };
 
            class AWS_CRT_CPP_API HttpClientConnectionProxyOptions
            {
              public:
                HttpClientConnectionProxyOptions();
                HttpClientConnectionProxyOptions(const HttpClientConnectionProxyOptions &rhs) = default;
                HttpClientConnectionProxyOptions(HttpClientConnectionProxyOptions &&rhs) = default;
 
                HttpClientConnectionProxyOptions &operator=(const HttpClientConnectionProxyOptions &rhs) = default;
                HttpClientConnectionProxyOptions &operator=(HttpClientConnectionProxyOptions &&rhs) = default;
 
                ~HttpClientConnectionProxyOptions() = default;
 
                void InitializeRawProxyOptions(struct aws_http_proxy_options &raw_options) const;
 
                String HostName;
 
                uint32_t Port;
 
                Optional<Io::TlsConnectionOptions> TlsOptions;
 
                AwsHttpProxyConnectionType ProxyConnectionType;
 
                std::shared_ptr<HttpProxyStrategy> ProxyStrategy;
 
                AwsHttpProxyAuthenticationType AuthType;
 
                String BasicAuthUsername;
 
                String BasicAuthPassword;
            };
 
            enum class ProxyEnvVarType
            {
                Disabled = AWS_HPEV_DISABLE,
                Enabled = AWS_HPEV_ENABLE,
            };
 
            class AWS_CRT_CPP_API ProxyEnvVarOptions
            {
              public:
                ProxyEnvVarOptions();
                ProxyEnvVarOptions(const ProxyEnvVarOptions &rhs) = default;
                ProxyEnvVarOptions(ProxyEnvVarOptions &&rhs) = default;
 
                ProxyEnvVarOptions &operator=(const ProxyEnvVarOptions &rhs) = default;
                ProxyEnvVarOptions &operator=(ProxyEnvVarOptions &&rhs) = default;
 
                ~ProxyEnvVarOptions() = default;
 
                void InitializeRawProxyOptions(struct proxy_env_var_settings &raw_options) const;
 
                ProxyEnvVarType proxyEnvVarType;
 
                AwsHttpProxyConnectionType connectionType;
 
                Optional<Io::TlsConnectionOptions> TlsOptions;
            };
 
            class AWS_CRT_CPP_API HttpClientConnectionOptions
            {
              public:
                HttpClientConnectionOptions();
                HttpClientConnectionOptions(const HttpClientConnectionOptions &rhs) = default;
                HttpClientConnectionOptions(HttpClientConnectionOptions &&rhs) = default;
 
                ~HttpClientConnectionOptions() = default;
 
                HttpClientConnectionOptions &operator=(const HttpClientConnectionOptions &rhs) = default;
                HttpClientConnectionOptions &operator=(HttpClientConnectionOptions &&rhs) = default;
 
                Io::ClientBootstrap *Bootstrap;
 
                size_t InitialWindowSize;
 
                OnConnectionSetup OnConnectionSetupCallback;
 
                OnConnectionShutdown OnConnectionShutdownCallback;
 
                String HostName;
 
                uint32_t Port;
 
                Io::SocketOptions SocketOptions;
 
                Optional<Io::TlsConnectionOptions> TlsOptions;
 
                Optional<HttpClientConnectionProxyOptions> ProxyOptions;
 
                std::shared_ptr<Aws::Crt::Io::L4ProxyConfig> L4ProxyOptions;
 
                bool ManualWindowManagement;
            };
 
            enum class HttpVersion
            {
                Unknown = AWS_HTTP_VERSION_UNKNOWN,
                Http1_0 = AWS_HTTP_VERSION_1_0,
                Http1_1 = AWS_HTTP_VERSION_1_1,
                Http2 = AWS_HTTP_VERSION_2,
            };
 
            class AWS_CRT_CPP_API HttpClientConnection : public std::enable_shared_from_this<HttpClientConnection>
            {
              public:
                virtual ~HttpClientConnection() = default;
                HttpClientConnection(const HttpClientConnection &) = delete;
                HttpClientConnection(HttpClientConnection &&) = delete;
                HttpClientConnection &operator=(const HttpClientConnection &) = delete;
                HttpClientConnection &operator=(HttpClientConnection &&) = delete;
 
                std::shared_ptr<HttpClientStream> NewClientStream(const HttpRequestOptions &requestOptions) noexcept;
 
                bool IsOpen() const noexcept;
 
                void Close() noexcept;
 
                HttpVersion GetVersion() noexcept;
 
                int LastError() const noexcept { return m_lastError; }
 
                static bool CreateConnection(
                    const HttpClientConnectionOptions &connectionOptions,
                    Allocator *allocator) noexcept;
 
              protected:
                HttpClientConnection(aws_http_connection *m_connection, Allocator *allocator) noexcept;
                aws_http_connection *m_connection;
 
              private:
                Allocator *m_allocator;
                int m_lastError;
 
                static void s_onClientConnectionSetup(
                    struct aws_http_connection *connection,
                    int error_code,
                    void *user_data) noexcept;
                static void s_onClientConnectionShutdown(
                    struct aws_http_connection *connection,
                    int error_code,
                    void *user_data) noexcept;
            };
 
        } // namespace Http
    } // namespace Crt
} // namespace Aws