SecureTunnel.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/http/HttpConnection.h>
#include <aws/crt/io/Bootstrap.h>
#include <aws/crt/io/SocketOptions.h>
#include <aws/iotdevice/secure_tunneling.h>
#include <aws/iotsecuretunneling/Exports.h>
 
#include <future>
 
namespace Aws
{
    namespace Iotsecuretunneling
    {
        class AWS_IOTSECURETUNNELING_API Message
        {
          public:
            Message(
                const aws_secure_tunnel_message_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
            Message(Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
            Message(Crt::ByteCursor payload, Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
            Message(
                Crt::ByteCursor payload,
                uint32_t connectionId,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
            Message(
                Crt::ByteCursor serviceId,
                Crt::ByteCursor payload,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
            Message(
                Crt::ByteCursor serviceId,
                uint32_t connectionId,
                Crt::ByteCursor payload,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            Message &WithServiceId(Crt::ByteCursor serviceId) noexcept;
 
            Message &WithConnectionId(uint32_t connectionId) noexcept;
 
            Message &WithPayload(Crt::ByteCursor payload) noexcept;
 
            bool initializeRawOptions(aws_secure_tunnel_message_view &raw_options) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId() const noexcept;
 
            const uint32_t &getConnectionId() const noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getPayload() const noexcept;
 
            virtual ~Message();
            /* Do not allow direct copy or move */
            Message(const Message &) = delete;
            Message(Message &&) noexcept = delete;
            Message &operator=(const Message &) = delete;
            Message &operator=(Message &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId;
 
            uint32_t m_connectionId;
 
            Crt::Optional<Crt::ByteCursor> m_payload;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_payloadStorage;
            Crt::ByteBuf m_serviceIdStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API MessageReceivedEventData
        {
            MessageReceivedEventData() : message(nullptr) {}
            std::shared_ptr<Message> message;
        };
 
        class AWS_IOTSECURETUNNELING_API SendMessageCompleteData
        {
          public:
            SendMessageCompleteData(
                enum aws_secure_tunnel_message_type type,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::ByteCursor &getMessageType() const noexcept;
 
            virtual ~SendMessageCompleteData();
            /* Do not allow direct copy or move */
            SendMessageCompleteData(const SendMessageCompleteData &) = delete;
            SendMessageCompleteData(SendMessageCompleteData &&) noexcept = delete;
            SendMessageCompleteData &operator=(const SendMessageCompleteData &) = delete;
            SendMessageCompleteData &operator=(SendMessageCompleteData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::ByteCursor m_messageType;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_messageTypeStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API SendMessageCompleteEventData
        {
            SendMessageCompleteEventData() : sendMessageCompleteData(nullptr) {}
            std::shared_ptr<SendMessageCompleteData> sendMessageCompleteData;
        };
 
        class AWS_IOTSECURETUNNELING_API ConnectionData
        {
          public:
            ConnectionData(
                const aws_secure_tunnel_connection_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId1() const noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId2() const noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId3() const noexcept;
 
            virtual ~ConnectionData();
            /* Do not allow direct copy or move */
            ConnectionData(const ConnectionData &) = delete;
            ConnectionData(ConnectionData &&) noexcept = delete;
            ConnectionData &operator=(const ConnectionData &) = delete;
            ConnectionData &operator=(ConnectionData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId1;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId2;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId3;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_serviceId1Storage;
            Crt::ByteBuf m_serviceId2Storage;
            Crt::ByteBuf m_serviceId3Storage;
        };
 
        struct AWS_IOTSECURETUNNELING_API ConnectionSuccessEventData
        {
            ConnectionSuccessEventData() : connectionData(nullptr) {}
            std::shared_ptr<ConnectionData> connectionData;
        };
 
        class AWS_IOTSECURETUNNELING_API StreamStartedData
        {
          public:
            StreamStartedData(
                const aws_secure_tunnel_message_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId() const noexcept;
 
            const uint32_t &getConnectionId() const noexcept;
 
            virtual ~StreamStartedData();
            /* Do not allow direct copy or move */
            StreamStartedData(const StreamStartedData &) = delete;
            StreamStartedData(StreamStartedData &&) noexcept = delete;
            StreamStartedData &operator=(const StreamStartedData &) = delete;
            StreamStartedData &operator=(StreamStartedData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId;
 
            uint32_t m_connectionId;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_serviceIdStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API StreamStartedEventData
        {
            StreamStartedEventData() : streamStartedData(nullptr) {}
            std::shared_ptr<StreamStartedData> streamStartedData;
        };
 
        class AWS_IOTSECURETUNNELING_API StreamStoppedData
        {
          public:
            StreamStoppedData(
                const aws_secure_tunnel_message_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId() const noexcept;
 
            virtual ~StreamStoppedData();
            /* Do not allow direct copy or move */
            StreamStoppedData(const StreamStoppedData &) = delete;
            StreamStoppedData(StreamStoppedData &&) noexcept = delete;
            StreamStoppedData &operator=(const StreamStoppedData &) = delete;
            StreamStoppedData &operator=(StreamStoppedData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_serviceIdStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API StreamStoppedEventData
        {
            StreamStoppedEventData() : streamStoppedData(nullptr) {}
            std::shared_ptr<StreamStoppedData> streamStoppedData;
        };
 
        class AWS_IOTSECURETUNNELING_API ConnectionStartedData
        {
          public:
            ConnectionStartedData(
                const aws_secure_tunnel_message_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId() const noexcept;
 
            const uint32_t &getConnectionId() const noexcept;
 
            virtual ~ConnectionStartedData();
            /* Do not allow direct copy or move */
            ConnectionStartedData(const ConnectionStartedData &) = delete;
            ConnectionStartedData(ConnectionStartedData &&) noexcept = delete;
            ConnectionStartedData &operator=(const ConnectionStartedData &) = delete;
            ConnectionStartedData &operator=(ConnectionStartedData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId;
 
            uint32_t m_connectionId;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_serviceIdStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API ConnectionStartedEventData
        {
            ConnectionStartedEventData() : connectionStartedData(nullptr) {}
            std::shared_ptr<ConnectionStartedData> connectionStartedData;
        };
 
        class AWS_IOTSECURETUNNELING_API ConnectionResetData
        {
          public:
            ConnectionResetData(
                const aws_secure_tunnel_message_view &raw_options,
                Crt::Allocator *allocator = Crt::ApiAllocator()) noexcept;
 
            const Crt::Optional<Crt::ByteCursor> &getServiceId() const noexcept;
 
            const uint32_t &getConnectionId() const noexcept;
 
            virtual ~ConnectionResetData();
            /* Do not allow direct copy or move */
            ConnectionResetData(const ConnectionResetData &) = delete;
            ConnectionResetData(ConnectionResetData &&) noexcept = delete;
            ConnectionResetData &operator=(const ConnectionResetData &) = delete;
            ConnectionResetData &operator=(ConnectionResetData &&) noexcept = delete;
 
          private:
            Crt::Allocator *m_allocator;
 
            Crt::Optional<Crt::ByteCursor> m_serviceId;
 
            uint32_t m_connectionId;
 
            // Underlying data storage for internal use
            Crt::ByteBuf m_serviceIdStorage;
        };
 
        struct AWS_IOTSECURETUNNELING_API ConnectionResetEventData
        {
            ConnectionResetEventData() : connectionResetData(nullptr) {}
            std::shared_ptr<ConnectionResetData> connectionResetData;
        };
 
        class SecureTunnel;
 
        // Client callback type definitions
 
        using OnConnectionSuccess = std::function<void(SecureTunnel *secureTunnel, const ConnectionSuccessEventData &)>;
 
        using OnConnectionFailure = std::function<void(SecureTunnel *secureTunnel, int errorCode)>;
 
        using OnConnectionShutdown = std::function<void(void)>;
 
        using OnSendMessageComplete =
            std::function<void(SecureTunnel *secureTunnel, int errorCode, const SendMessageCompleteEventData &)>;
 
        using OnMessageReceived = std::function<void(SecureTunnel *secureTunnel, const MessageReceivedEventData &)>;
 
        using OnStreamStarted =
            std::function<void(SecureTunnel *secureTunnel, int errorCode, const StreamStartedEventData &)>;
 
        using OnStreamStopped = std::function<void(SecureTunnel *secureTunnel, const StreamStoppedEventData &)>;
 
        using OnConnectionStarted =
            std::function<void(SecureTunnel *secureTunnel, int errorCode, const ConnectionStartedEventData &)>;
 
        using OnConnectionReset =
            std::function<void(SecureTunnel *secureTunnel, int errorCode, const ConnectionResetEventData &)>;
 
        using OnSessionReset = std::function<void(void)>;
 
        using OnStopped = std::function<void(SecureTunnel *secureTunnel)>;
 
        using OnConnectionComplete = std::function<void(void)>;
        using OnDataReceive = std::function<void(const Crt::ByteBuf &data)>;
        using OnStreamStart = std::function<void()>;
        using OnStreamReset = std::function<void(void)>;
        using OnSendDataComplete = std::function<void(int errorCode)>;
 
        class AWS_IOTSECURETUNNELING_API SecureTunnelBuilder final
        {
          public:
            SecureTunnelBuilder(
                Crt::Allocator *allocator,                   // Should out live this object
                Crt::Io::ClientBootstrap &clientBootstrap,   // Should out live this object
                const Crt::Io::SocketOptions &socketOptions, // Make a copy and save in this object
                const std::string &accessToken,              // Make a copy and save in this object
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost); // Make a copy and save in this object
 
            SecureTunnelBuilder(
                Crt::Allocator *allocator,                   // Should out live this object
                const Crt::Io::SocketOptions &socketOptions, // Make a copy and save in this object
                const std::string &accessToken,              // Make a copy and save in this object
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost); // Make a copy and save in this object
 
            SecureTunnelBuilder(
                Crt::Allocator *allocator,      // Should out live this object
                const std::string &accessToken, // Make a copy and save in this object
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost); // Make a copy and save in this object
 
            /* Optional members */
 
            SecureTunnelBuilder &WithTlsConnectionOptions(const Crt::Io::TlsConnectionOptions &tslOptions);
 
            SecureTunnelBuilder &WithRootCa(const std::string &rootCa);
 
            SecureTunnelBuilder &WithClientToken(const std::string &clientToken);
 
            SecureTunnelBuilder &WithHttpClientConnectionProxyOptions(
                const Crt::Http::HttpClientConnectionProxyOptions &httpClientConnectionProxyOptions);
 
            SecureTunnelBuilder &WithOnConnectionSuccess(OnConnectionSuccess onConnectionSuccess);
 
            SecureTunnelBuilder &WithOnConnectionFailure(OnConnectionFailure onConnectionFailure);
 
            SecureTunnelBuilder &WithOnConnectionShutdown(OnConnectionShutdown onConnectionShutdown);
 
            SecureTunnelBuilder &WithOnSendMessageComplete(OnSendMessageComplete onSendMessageComplete);
 
            SecureTunnelBuilder &WithOnMessageReceived(OnMessageReceived onMessageReceived);
 
            SecureTunnelBuilder &WithOnStreamStarted(OnStreamStarted onStreamStarted);
 
            SecureTunnelBuilder &WithOnStreamStopped(OnStreamStopped onStreamStopped);
 
            SecureTunnelBuilder &WithOnConnectionStarted(OnConnectionStarted onConnectionStarted);
 
            SecureTunnelBuilder &WithOnConnectionReset(OnConnectionReset onConnectionReset);
 
            SecureTunnelBuilder &WithOnStreamReset(OnStreamReset onStreamReset);
 
            SecureTunnelBuilder &WithOnSessionReset(OnSessionReset onSessionReset);
 
            SecureTunnelBuilder &WithOnStopped(OnStopped onStopped);
 
            SecureTunnelBuilder &WithOnDataReceive(OnDataReceive onDataReceive);
            SecureTunnelBuilder &WithOnConnectionComplete(OnConnectionComplete onConnectionComplete);
            SecureTunnelBuilder &WithOnStreamStart(OnStreamStart onStreamStart);
            SecureTunnelBuilder &WithOnSendDataComplete(OnSendDataComplete onSendDataComplete);
 
            std::shared_ptr<SecureTunnel> Build() noexcept;
 
          private:
            /* Required Memebers */
 
            Crt::Allocator *m_allocator;
 
            Crt::Io::ClientBootstrap *m_clientBootstrap;
 
            Crt::Io::SocketOptions m_socketOptions;
 
            std::string m_accessToken;
 
            aws_secure_tunneling_local_proxy_mode m_localProxyMode;
 
            std::string m_endpointHost;
 
            /* Optional members */
            std::string m_clientToken;
 
            Crt::Optional<Crt::Io::TlsConnectionOptions> m_tlsConnectionOptions;
 
            std::string m_rootCa;
 
            Crt::Optional<Crt::Http::HttpClientConnectionProxyOptions> m_httpClientConnectionProxyOptions;
 
            /* Callbacks */
            OnConnectionSuccess m_OnConnectionSuccess;
 
            /* Callbacks */
            OnConnectionFailure m_OnConnectionFailure;
 
            OnConnectionShutdown m_OnConnectionShutdown;
 
            OnSendMessageComplete m_OnSendMessageComplete;
 
            OnMessageReceived m_OnMessageReceived;
 
            OnStreamStarted m_OnStreamStarted;
 
            OnStreamStopped m_OnStreamStopped;
 
            OnConnectionStarted m_OnConnectionStarted;
 
            OnConnectionReset m_OnConnectionReset;
 
            OnSessionReset m_OnSessionReset;
 
            OnStopped m_OnStopped;
 
            OnConnectionComplete m_OnConnectionComplete;
            OnDataReceive m_OnDataReceive;
            OnStreamStart m_OnStreamStart;
            OnStreamReset m_OnStreamReset;
            OnSendDataComplete m_OnSendDataComplete;
 
            friend class SecureTunnel;
        };
 
        class AWS_IOTSECURETUNNELING_API SecureTunnel final
        {
          public:
            SecureTunnel(
                Crt::Allocator *allocator,                   // Should out live this object
                Crt::Io::ClientBootstrap *clientBootstrap,   // Should out live this object
                const Crt::Io::SocketOptions &socketOptions, // Make a copy and save in this object
 
                const std::string &accessToken, // Make a copy and save in this object
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost, // Make a copy and save in this object
                const std::string &rootCa,       // Make a copy and save in this object
 
                OnConnectionComplete onConnectionComplete,
                OnConnectionShutdown onConnectionShutdown,
                OnSendDataComplete onSendDataComplete,
                OnDataReceive onDataReceive,
                OnStreamStart onStreamStart,
                OnStreamReset onStreamReset,
                OnSessionReset onSessionReset);
 
            SecureTunnel(
                Crt::Allocator *allocator,                   // Should out live this object
                const Crt::Io::SocketOptions &socketOptions, // Make a copy and save in this object
 
                const std::string &accessToken, // Make a copy and save in this object
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost, // Make a copy and save in this object
                const std::string &rootCa,       // Make a copy and save in this object
 
                OnConnectionComplete onConnectionComplete,
                OnConnectionShutdown onConnectionShutdown,
                OnSendDataComplete onSendDataComplete,
                OnDataReceive onDataReceive,
                OnStreamStart onStreamStart,
                OnStreamReset onStreamReset,
                OnSessionReset onSessionReset);
 
            virtual ~SecureTunnel();
            SecureTunnel(const SecureTunnel &) = delete;
            SecureTunnel &operator=(const SecureTunnel &) = delete;
 
            SecureTunnel(SecureTunnel &&) noexcept;
            SecureTunnel &operator=(SecureTunnel &&) noexcept;
 
            bool IsValid();
 
            int Start();
 
            int Stop();
 
            int SendMessage(std::shared_ptr<Message> messageOptions) noexcept;
 
            /* SOURCE MODE ONLY */
            int SendStreamStart();
 
            int SendStreamStart(std::string serviceId);
 
            int SendStreamStart(Crt::ByteCursor serviceId);
 
            int SendStreamStart(std::string serviceId, uint32_t connectionId);
 
            int SendStreamStart(Crt::ByteCursor serviceId, uint32_t connectionId);
 
            int SendConnectionStart(uint32_t connectionId);
 
            int SendConnectionStart(std::string serviceId, uint32_t connectionId);
 
            int SendConnectionStart(Crt::ByteCursor serviceId, uint32_t connectionId);
 
            aws_secure_tunnel *GetUnderlyingHandle();
 
            int Connect();
 
            int Close();
 
            void Shutdown();
 
            int SendData(const Crt::ByteCursor &data);
 
            /* Should not be exposed. Under the hood only operation. */
            int SendStreamReset();
 
          private:
            SecureTunnel(
                Crt::Allocator *allocator,
                Crt::Io::ClientBootstrap *clientBootstrap,
                const Crt::Io::SocketOptions &socketOptions,
                const std::string &accessToken,
                const std::string &clientToken,
                aws_secure_tunneling_local_proxy_mode localProxyMode,
                const std::string &endpointHost,
 
                Crt::Io::TlsConnectionOptions *tslOptions,
                const std::string &rootCa,
                Crt::Http::HttpClientConnectionProxyOptions *httpClientConnectionProxyOptions,
 
                OnConnectionSuccess onConnectionSuccess,
                OnConnectionFailure onConnectionFailure,
                OnConnectionComplete onConnectionComplete, /* Deprecated */
                OnConnectionShutdown onConnectionShutdown,
                OnSendMessageComplete onSendMessageComplete,
                OnSendDataComplete onSendDataComplete, /* Deprecated */
                OnMessageReceived onMessageReceived,
                OnDataReceive onDataReceive, /* Deprecated */
                OnStreamStarted onStreamStarted,
                OnStreamStart onStreamStart, /* Deprecated */
                OnStreamStopped onStreamStopped,
                OnStreamReset onStreamReset, /* Deprecated */
                OnConnectionStarted onConnectionStarted,
                OnConnectionReset onConnectionReset,
                OnSessionReset onSessionReset,
                OnStopped onStopped);
 
            /* Static Callbacks */
            static void s_OnMessageReceived(const struct aws_secure_tunnel_message_view *message, void *user_data);
            static void s_OnConnectionComplete(
                const struct aws_secure_tunnel_connection_view *connection,
                int error_code,
                void *user_data);
            static void s_OnConnectionFailure(int error_code, void *user_data);
            static void s_OnConnectionShutdown(int error_code, void *user_data);
            static void s_OnSendDataComplete(int error_code, void *user_data);
            static void s_OnSendMessageComplete(
                enum aws_secure_tunnel_message_type type,
                int error_code,
                void *user_data);
            static void s_OnStreamStopped(
                const struct aws_secure_tunnel_message_view *message,
                int error_code,
                void *user_data);
            static void s_OnSessionReset(void *user_data);
            static void s_OnStopped(void *user_data);
            static void s_OnTerminationComplete(void *user_data);
            static void s_OnStreamStarted(
                const struct aws_secure_tunnel_message_view *message,
                int error_code,
                void *user_data);
            static void s_OnConnectionStarted(
                const struct aws_secure_tunnel_message_view *message,
                int error_code,
                void *user_data);
            static void s_OnConnectionReset(
                const struct aws_secure_tunnel_message_view *message,
                int error_code,
                void *user_data);
 
            void OnTerminationComplete();
 
            OnMessageReceived m_OnMessageReceived;
 
            OnConnectionSuccess m_OnConnectionSuccess;
 
            OnConnectionFailure m_OnConnectionFailure;
 
            OnConnectionShutdown m_OnConnectionShutdown;
 
            OnSendMessageComplete m_OnSendMessageComplete;
 
            OnStreamStarted m_OnStreamStarted;
 
            OnStreamStopped m_OnStreamStopped;
 
            OnConnectionStarted m_OnConnectionStarted;
 
            OnConnectionReset m_OnConnectionReset;
 
            OnSessionReset m_OnSessionReset;
 
            OnStopped m_OnStopped;
 
            aws_secure_tunnel *m_secure_tunnel;
            Crt::Allocator *m_allocator;
 
            OnDataReceive m_OnDataReceive;
            OnConnectionComplete m_OnConnectionComplete;
            OnStreamStart m_OnStreamStart;
            OnStreamReset m_OnStreamReset;
            OnSendDataComplete m_OnSendDataComplete;
 
            std::shared_ptr<SecureTunnel> m_selfRef;
 
            friend class SecureTunnelBuilder;
        };
    } // namespace Iotsecuretunneling
} // namespace Aws