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