Addressed PR feedback, fixed move semantics errors.

Author: JonathanHenson

include/aws/crt/StlAllocator.h

@@ -0,0 +1,63 @@
+#pragma once
+/*
+* Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+*  http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file is distributed
+* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+* express or implied. See the License for the specific language governing
+* permissions and limitations under the License.
+*/
+
+#include <aws/crt/Types.h>
+
+#include <memory>
+
+namespace Aws
+{
+    namespace Crt
+    {
+        extern Allocator* g_allocator;
+
+        template<typename T>
+        class StlAllocator final : public std::allocator<T>
+        {
+        public:
+            using Base = std::allocator<T>;
+
+            StlAllocator() noexcept : Base() {}
+            StlAllocator(const StlAllocator<T>& a) noexcept : Base(a) {}
+            
+            template<class U>
+            StlAllocator(const StlAllocator<U>& a) noexcept : Base(a) {}
+
+            ~StlAllocator() {}
+
+            using sizeType = std::size_t;
+
+            template<typename U>
+            struct rebind
+            {
+                typedef StlAllocator<U> other;
+            };
+
+            typename Base::pointer allocate(size_type n, const void* hint = nullptr)
+            {
+                (void)hint;
+                assert(g_allocator);
+                return reinterpret_cast<typename Base::pointer>(aws_mem_acquire(g_allocator, n * sizeof(T)));
+            }
+
+            void deallocate(typename Base::pointer p, size_type)
+            {
+                assert(g_allocator);
+                aws_mem_release(g_allocator, p);
+            }
+        };
+    }
+}

include/aws/crt/Types.h

@@ -35,7 +35,7 @@ namespace Aws
         AWS_CRT_CPP_API Allocator* DefaultAllocator() noexcept;
         AWS_CRT_CPP_API ByteBuf ByteBufFromCString(const char* str) noexcept;
         AWS_CRT_CPP_API ByteBuf ByteBufFromArray(const uint8_t *array, size_t len) noexcept;
-
+        
         namespace Io
         {
            using SocketOptions = aws_socket_options;

include/aws/crt/io/TlsOptions.h

@@ -28,7 +28,7 @@ namespace Aws
         {
             using TlsConnectionOptions = aws_tls_connection_options;
 
-            enum class TLSMode
+            enum class TlsMode
             {
                 CLIENT,
                 SERVER,
@@ -41,15 +41,58 @@ namespace Aws
                 TlsContextOptions(const TlsContextOptions&) noexcept = default;
                 TlsContextOptions& operator=(const TlsContextOptions&) noexcept = default;
 
+                /**
+                 * Initializes TlsContextOptions with secure by default options, with
+                 * no client certificates.
+                 */
                 static TlsContextOptions InitDefaultClient() noexcept;
+                /**
+                 * Initializes TlsContextOptions with secure by default options, with
+                 * client certificate and private key. These are paths to a file on disk. These
+                 * strings must remain in memory for the lifetime of the returned object. These files
+                 * must be in the PEM format.
+                 */
                 static TlsContextOptions InitClientWithMtls(const char *cert_path, const char *pkey_path) noexcept;
+
+                /**
+                * Initializes TlsContextOptions with secure by default options, with
+                * client certificateand private key in the PKCS#12 format. 
+                * This is a path to a file on disk. These
+                * strings must remain in memory for the lifetime of the returned object.
+                */
                 static TlsContextOptions InitClientWithMtlsPkcs12(const char *pkcs12_path,
                         const char *pkcs12_pwd) noexcept;
+
+                /**
+                 * Returns true if alpn is supported by the underlying security provider, false
+                 * otherwise.
+                 */
                 static bool IsAlpnSupported() noexcept;
 
+                /**
+                 * Sets the list of alpn protocols, delimited by ';'. This string must remain in memory
+                 * for the lifetime of this object.
+                 */
                 void SetAlpnList(const char* alpnList) noexcept;
+
+                /**
+                 * In client mode, this turns off x.509 validation. Don't do this unless you're testing.
+                 * It's much better, to just override the default trust store and pass the self-signed 
+                 * certificate as the caFile argument.
+                 *
+                 * In server mode, this defaults to false. If you want to support mutual TLS from the server, 
+                 * you'll want to set this to true.
+                 */
                 void SetVerifyPeer(bool verifyPeer) noexcept;
-                void OverrideDefaultTrustStore(const char* caPath, const char*caFile) noexcept;
+
+                /**
+                 * Overrides the default system trust store. caPath is only useful on Unix style systems where
+                 * all anchors are stored in a directory (like /etc/ssl/certs). caFile is for a single file containing
+                 * all trusted CAs. caFile must be in the PEM format. 
+                 *
+                 * These strings must remain in memory for the lifetime of this object.
+                 */
+                void OverrideDefaultTrustStore(const char* caPath, const char* caFile) noexcept;
 
             private:
                 aws_tls_ctx_options m_options;
@@ -60,7 +103,7 @@ namespace Aws
             class AWS_CRT_CPP_API TlsContext final
             {
             public:
-                TlsContext(TlsContextOptions& options, TLSMode mode, Allocator* allocator = DefaultAllocator()) noexcept;
+                TlsContext(TlsContextOptions& options, TlsMode mode, Allocator* allocator = DefaultAllocator()) noexcept;
                 ~TlsContext();
                 TlsContext(const TlsContext&) = delete;
                 TlsContext& operator=(const TlsContext&) = delete;

include/aws/crt/mqtt/MqttClient.h

@@ -49,7 +49,7 @@ namespace Aws
             /**
              * Invoked Upon Connection failure.
              */
-            using OnConnectionFailedHandler = std::function<void(MqttConnection& connection)>;
+            using OnConnectionFailedHandler = std::function<void(MqttConnection& connection, int error)>;
 
             /**
              * Invoked when a connack message is received.
@@ -60,7 +60,7 @@ namespace Aws
             /**
              * Invoked when a disconnect message has been sent.
              */
-            using OnDisconnectHandler = std::function<bool(MqttConnection& connection)>;
+            using OnDisconnectHandler = std::function<bool(MqttConnection& connection, int error)>;
 
             /**
              * Invoked upon receipt of a Publish message on a subscribed topic.
@@ -70,18 +70,20 @@ namespace Aws
             using OnOperationCompleteHandler = std::function<void(MqttConnection& connection, uint16_t packetId)>;
 
             /**
-             * Represents a persistent Mqtt Connection. The memory is owned by MqttClient. This is a move only type.
-             * To get a new instance of this class, see MqttClient::NewConnection.
+             * Represents a persistent Mqtt Connection. The memory is owned by MqttClient.
+             * To get a new instance of this class, see MqttClient::NewConnection. Unless
+             * specified all function arguments need only to live through the duration of the 
+             * function call.
              */
             class AWS_CRT_CPP_API MqttConnection final
             {
                 friend class MqttClient;
             public:
                 ~MqttConnection();
                 MqttConnection(const MqttConnection&) = delete;
-                MqttConnection(MqttConnection&&);
+                MqttConnection(MqttConnection&&) = delete;
                 MqttConnection& operator =(const MqttConnection&) = delete;
-                MqttConnection& operator =(MqttConnection&&);
+                MqttConnection& operator =(MqttConnection&&) = delete;
 
                 operator bool() const noexcept;
                 int LastError() const noexcept;
@@ -154,19 +156,18 @@ namespace Aws
                 void Ping();
 
             private:
-                MqttConnection(MqttClient* client, const char* hostName, uint16_t port,
+                MqttConnection(aws_mqtt_client* client, const char* hostName, uint16_t port,
                                const Io::SocketOptions& socketOptions,
                                Io::TlsConnectionOptions&& tlsConnOptions) noexcept;
-                MqttConnection(MqttClient* client, const char* hostName, uint16_t port,
+                MqttConnection(aws_mqtt_client* client, const char* hostName, uint16_t port,
                                const Io::SocketOptions& socketOptions) noexcept;
 
-                MqttClient *m_owningClient;
+                aws_mqtt_client* m_owningClient;
                 aws_mqtt_client_connection *m_underlyingConnection;
 
                 OnConnectionFailedHandler m_onConnectionFailed;
                 OnConnAckHandler m_onConnAck;
                 OnDisconnectHandler m_onDisconnect;
-                std::atomic<int> m_lastError;
                 std::atomic<ConnectionState> m_connectionState;
 
                 static void s_onConnectionFailed(aws_mqtt_client_connection* connection, int errorCode, void* userData);
@@ -185,11 +186,12 @@ namespace Aws
             };
 
             /**
-             * An MQTT client. This is a move-only type.
+             * An MQTT client. This is a move-only type. Unless otherwise specified,  
+             * all function arguments need only to live through the duration of the 
+             * function call.
              */
             class AWS_CRT_CPP_API MqttClient final
             {
-                friend class MqttConnection;
             public:
                 /**
                  * Initialize an MqttClient using bootstrap and allocator
@@ -209,19 +211,17 @@ namespace Aws
                  * Create a new connection object using TLS from the client. The client must outlive
                  * all of its connection instances.
                  */
-                MqttConnection NewConnection(const char* hostName, uint16_t port,
+                std::shared_ptr<MqttConnection> NewConnection(const char* hostName, uint16_t port,
                         const Io::SocketOptions& socketOptions, Io::TlsConnectionOptions&& tlsConnOptions) noexcept;
                 /**
                 * Create a new connection object over plain text from the client. The client must outlive
                 * all of its connection instances.
                 */
-                MqttConnection NewConnection(const char* hostName, uint16_t port,
+                std::shared_ptr<MqttConnection> NewConnection(const char* hostName, uint16_t port,
                     const Io::SocketOptions& socketOptions) noexcept;
 
             private:
-                aws_mqtt_client m_client;
-                int m_lastError;
-                bool m_isInit;
+                aws_mqtt_client* m_client;
             };
         }
     }

samples/mqtt_pub_sub/main.cpp

@@ -121,7 +121,7 @@ int main(int argc, char* argv[])
         port = 443;
     }
 
-    Io::TlsContext tlsCtx(tlsCtxOptions, Io::TLSMode::CLIENT);
+    Io::TlsContext tlsCtx(tlsCtxOptions, Io::TlsMode::CLIENT);
 
     if (!tlsCtx)
     {
@@ -173,13 +173,13 @@ int main(int argc, char* argv[])
      * Now create a connection object. Note: This type is move only
      * and its underlying memory is managed by the client.
      */
-    Mqtt::MqttConnection connection =
+    auto connection =
         mqttClient.NewConnection(endpoint.c_str(), port, socketOptions, tlsCtx.NewConnectionOptions());
 
-    if (!connection)
+    if (!*connection)
     {
         fprintf(stderr, "MQTT Connection Creation failed with error %s\n",
-            ErrorDebugString(connection.LastError()));
+            ErrorDebugString(connection->LastError()));
         exit(-1);
     }
 
@@ -200,7 +200,7 @@ int main(int argc, char* argv[])
     {
         {
             fprintf(stdout, "Connection completed with return code %d\n", returnCode);
-            fprintf(stdout, "Conneciton state %d\n", connection.GetConnectionState());
+            fprintf(stdout, "Conneciton state %d\n", connection->GetConnectionState());
             std::lock_guard<std::mutex> lockGuard(mutex);
             connectionSucceeded = true;
         }
@@ -210,10 +210,10 @@ int main(int argc, char* argv[])
     /*
      * This will be invoked when the TCP connection fails.
      */
-    auto onConFailure = [&](Mqtt::MqttConnection& connection)
+    auto onConFailure = [&](Mqtt::MqttConnection&, int error)
     {
         {
-            fprintf(stdout, "Connection failed with %s\n", ErrorDebugString(connection.LastError()));
+            fprintf(stdout, "Connection failed with %s\n", ErrorDebugString(error));
             std::lock_guard<std::mutex> lockGuard(mutex);
             connectionClosed = true;
         }
@@ -223,29 +223,29 @@ int main(int argc, char* argv[])
     /*
      * Invoked when a disconnect message has completed.
      */
-    auto onDisconnect = [&](Mqtt::MqttConnection&) -> bool
+    auto onDisconnect = [&](Mqtt::MqttConnection& conn, int error) -> bool
     {
         {
-            fprintf(stdout, "Connection closed\n");
-            fprintf(stdout, "Conneciton state %d\n", connection.GetConnectionState());
+            fprintf(stdout, "Connection closed with error %s\n", ErrorDebugString(error));
+            fprintf(stdout, "Conneciton state %d\n", conn.GetConnectionState());
             std::lock_guard<std::mutex> lockGuard(mutex);
             connectionClosed = true;
         }
         conditionVariable.notify_one();
         return false;
     };
 
-    connection.SetOnConnAckHandler(std::move(onConAck));
-    connection.SetOnConnectionFailedHandler(std::move(onConFailure));
-    connection.SetOnDisconnectHandler(std::move(onDisconnect));
+    connection->SetOnConnAckHandler(std::move(onConAck));
+    connection->SetOnConnectionFailedHandler(std::move(onConFailure));
+    connection->SetOnDisconnectHandler(std::move(onDisconnect));
 
     /*
      * Actually perform the connect dance.
      */
-    if (!connection.Connect("client_id12335456", true, 0))
+    if (!connection->Connect("client_id12335456", true, 0))
     {
         fprintf(stderr, "MQTT Connection failed with error %s\n",
-            ErrorDebugString(connection.LastError()));
+            ErrorDebugString(connection->LastError()));
         exit(-1);
     }
 
@@ -283,7 +283,7 @@ int main(int argc, char* argv[])
         /*
          * Publish our message.
          */
-        auto packetId = connection.Publish("a/b", AWS_MQTT_QOS_AT_LEAST_ONCE,
+        auto packetId = connection->Publish("a/b", AWS_MQTT_QOS_AT_LEAST_ONCE,
             false, helloWorldPayload, onOpComplete);
         (void)packetId;
         conditionVariable.wait(uniqueLock);
@@ -305,20 +305,20 @@ int main(int argc, char* argv[])
         /*
          * Subscribe for incoming publish messages on topic.
          */
-        packetId = connection.Subscribe("a/b", AWS_MQTT_QOS_AT_LEAST_ONCE, onPublish, onOpComplete);
+        packetId = connection->Subscribe("a/b", AWS_MQTT_QOS_AT_LEAST_ONCE, onPublish, onOpComplete);
         conditionVariable.wait(uniqueLock);
 
         waitForSub = false;
         /*
          * Unsubscribe from the topic.
          */
-        connection.Unsubscribe("a/b", onOpComplete);
+        connection->Unsubscribe("a/b", onOpComplete);
         conditionVariable.wait(uniqueLock);
     }
 
     if (!connectionClosed) {
         /* Disconnect */
-        connection.Disconnect();
+        connection->Disconnect();
         conditionVariable.wait(uniqueLock, [&]() { return connectionClosed; });
     }
     return 0;